# CVE-2026-108412 — rdbss.sys patch diff

`rdbss.sys` 10.0.26100.9818 -> 10.0.26100.9974 (ghidriff).

## `RxSetRenameLinkClusterInfo`  (modified)

```diff
--- RxSetRenameLinkClusterInfo
+++ RxSetRenameLinkClusterInfo
@@ -1,18 +1,302 @@
+

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

 

 ulonglong RxSetRenameLinkClusterInfo

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

                     longlong *param_5)

 

 {

-  ulonglong uVar1;

+  longlong lVar1;

+  longlong lVar2;

+  undefined8 *puVar3;

+  undefined8 uVar4;

+  bool bVar5;

+  char cVar6;

+  int iVar7;

+  ulonglong uVar8;

+  void *_Dst;

+  longlong ***ppplVar9;

+  uint uVar10;

+  ulonglong uVar11;

+  ulonglong uVar12;

+  undefined *_Size;

+  ushort uVar13;

+  ushort uVar14;

+  ushort *puVar15;

+  wchar_t wVar16;

+  wchar_t wVar17;

+  undefined2 uVar18;

+  undefined2 uVar19;

+  undefined2 uVar20;

+  undefined2 uVar21;

+  uint local_res8;

+  undefined8 *local_res10;

+  ulonglong local_res20;

+  undefined2 uStack_64;

+  undefined2 uStack_62;

+  undefined8 uStack_60;

+  undefined8 local_58;

+  undefined8 uStack_50;

   

+  uVar12 = 0;

+  ppplVar9 = param_3[0xf];

+  lVar1 = *(longlong *)(param_2 + 0x18);

+  lVar2 = *(longlong *)(param_2 + 0xb8);

+  local_58 = 0;

+  uStack_50 = (void *)0x0;

+  local_res20 = param_4 & 0xffffffffffffff00;

+  uStack_60 = (void *)0x0;

+  local_res10 = (undefined8 *)0x0;

+  *param_5 = 0;

+  *(undefined1 *)(param_1 + 0x1cc) = *(undefined1 *)(lVar2 + 0x20);

+  if (0xfffe < *(uint *)(lVar1 + 0x10)) {

+    uVar11 = 0xc0000106;

+    goto LAB_0;

+  }

+  uVar8 = RxpBuildTargetFcbTableNameForRename

+                    (param_1,param_2,(wchar_t *)&local_58,(undefined1 *)&local_res20);

+  uVar11 = uVar8 & 0xffffffff;

+  if ((int)uVar8 < 0) goto LAB_0;

+  if (*(longlong *)(lVar2 + 0x18) == 0) {

+    *(undefined8 *)(lVar1 + 8) = 0;

+    *(undefined8 *)(param_1 + 0x1b8) = *(undefined8 *)(param_2 + 0x18);

+    uVar10 = *(int *)(lVar1 + 0x10) + 0x14;

+    *(undefined1 *)(param_1 + 0x1cf) = 1;

+  }

+  else {

+    lVar1 = *(longlong *)(*(longlong *)(lVar2 + 0x18) + 0x18);

+    bVar5 = RxFcbClaimedByLogicalRdr((longlong)param_3);

+    puVar15 = (ushort *)(lVar1 + 0x168);

+    if (bVar5) {

+      puVar15 = (ushort *)&local_58;

+    }

+    if ((((undefined **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+        ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+       (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+      WPP_SF_Z(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x20,

+               &WPP_ab16eb3fa49233b1d38e2865df17878b_Traceguids,(wchar_t *)&local_58);

+    }

+    if ((*(longlong ****)(lVar1 + 0x78) != ppplVar9) ||

+       (param_3[0x10] != *(longlong ****)(lVar1 + 0x80))) {

+      uVar11 = 0xc00000d4;

+      goto LAB_0;

+    }

+    uVar10 = *puVar15 + 0x14;

+    uVar11 = Feature_1788238136__private_IsEnabledDeviceUsageNoInline();

+    if (((int)uVar11 != 0) && (uVar10 < 0x19)) {

+      uVar10 = 0x18;

+    }

+    local_res10 = (undefined8 *)ExAllocatePool2(0x102,uVar10,0x3f3f7852);

+    if (local_res10 == (undefined8 *)0x0) {

+      uVar11 = 0xc000009a;

+      goto LAB_0;

+    }

+    puVar3 = *(undefined8 **)(param_2 + 0x18);

+    uVar4 = puVar3[1];

+    *local_res10 = *puVar3;

+    local_res10[1] = uVar4;

+    local_res10[2] = puVar3[2];

+    local_res10[1] = 0;

+    *(uint *)(local_res10 + 2) = (uint)*puVar15;

+    memmove((void *)((longlong)local_res10 + 0x14),*(void **)(puVar15 + 4),(ulonglong)*puVar15);

+    *(undefined8 **)(param_1 + 0x1b8) = local_res10;

+  }

+  *(uint *)(param_1 + 0x1c8) = uVar10;

+  if ((*(int *)(lVar2 + 0x10) == 0xb) ||

+     (cVar6 = RtlEqualUnicodeString(param_3 + 0x2a,&local_58,0), uVar11 = uVar12, cVar6 == '\0')) {

+    *(undefined4 *)(param_1 + 0x1b0) = *(undefined4 *)(lVar2 + 0x10);

+    if (*(longlong *)(*(longlong *)(*(longlong *)(param_1 + 0x38) + 0x188) + 0xd0) == 0) {

+      uVar11 = 0xc0000002;

+    }

+    else if ((*(uint *)(param_1 + 0x80) & 2) == 0) {

+      *(undefined8 *)(param_1 + 0xd0) = 0;

+      *(undefined8 *)(param_1 + 0xd8) = 0;

+      *(undefined8 *)(param_1 + 0xe0) = 0;

+      *(undefined8 *)(param_1 + 0xe8) = 0;

+      uVar10 = (**(code **)(*(longlong *)(*(longlong *)(param_1 + 0x38) + 0x188) + 0xd0))(param_1);

+      uVar11 = (ulonglong)uVar10;

+      if ((-1 < (int)uVar10) && (*(int *)(lVar2 + 0x10) == 10)) {

+        if ((char)local_res20 == '\0') {

+          _Dst = (void *)ExAllocatePool2(0x102,local_58 & 0xffff,0x3f3f7852);

+          uStack_60 = _Dst;

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

+            uVar11 = 0xc000009a;

+            goto LAB_1;

+          }

+          wVar16 = (wchar_t)local_58;

+          memmove(_Dst,uStack_50,local_58 & 0xffff);

+          uStack_64 = 0;

+          uStack_62 = 0;

+          uStack_60._0_2_ = SUB82(_Dst,0);

+          uStack_60._2_2_ = (undefined2)((ulonglong)_Dst >> 0x10);

+          uStack_60._4_2_ = (undefined2)((ulonglong)_Dst >> 0x20);

+          uStack_60._6_2_ = (undefined2)((ulonglong)_Dst >> 0x30);

+          uVar20 = uStack_60._4_2_;

+          uVar21 = uStack_60._6_2_;

+          wVar17 = wVar16;

+          uVar18 = (undefined2)uStack_60;

+          uVar19 = uStack_60._2_2_;

+        }

+        else {

+          uStack_60 = uStack_50;

+          wVar16 = (wchar_t)local_58;

+          uVar20 = uStack_50._4_2_;

+          uVar21 = uStack_50._6_2_;

+          wVar17 = local_58._2_2_;

+          uStack_64 = local_58._4_2_;

+          uStack_62 = local_58._6_2_;

+          uVar18 = (undefined2)uStack_50;

+          uVar19 = uStack_50._2_2_;

+        }

+        if ((((undefined **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+            ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+           (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+          WPP_SF_Z(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x21,

+                   &WPP_ab16eb3fa49233b1d38e2865df17878b_Traceguids,(wchar_t *)(param_3 + 0x2d));

+        }

+        ppplVar9 = param_3[0x10];

+        uVar14 = 0;

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

+          local_res8 = 0;

+        }

+        else {

+          uVar12 = (ulonglong)*(ushort *)ppplVar9[7];

+          uVar14 = *(ushort *)(ppplVar9 + 8) - *(ushort *)param_3[0xf][0xb];

+          local_res8 = (uint)*(ushort *)ppplVar9[7];

+          if (*(ushort *)(ppplVar9 + 8) <= *(ushort *)param_3[0xf][0xb]) {

+            uVar14 = 0;

+          }

+        }

+        uVar13 = (*(short *)(param_3 + 0x23) - (short)uVar12) + wVar16 + uVar14;

+        if (*(ushort *)(param_3 + 0x2d) < uVar13) {

+          ppplVar9 = (longlong ***)ExAllocatePool2(0x102,uVar13,0x3f3f7852);

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

+            uVar11 = 0xc000009a;

+            goto LAB_1;

+          }

+          if (*(ushort *)(param_3 + 0x23) != 0) {

+            memmove(ppplVar9,param_3[0x2e],(ulonglong)*(ushort *)(param_3 + 0x23));

+          }

+          if ((*(uint *)((longlong)param_3 + 0x9c) & 0x8000) != 0) {

+            ExFreePoolWithTag(param_3[0x2e],0);

+            param_3[0x2e] = (longlong ***)0x0;

+          }

+          *(uint *)((longlong)param_3 + 0x9c) = *(uint *)((longlong)param_3 + 0x9c) | 0x8000;

+          param_3[0x2e] = ppplVar9;

+          uVar12 = (ulonglong)local_res8;

+          *(ushort *)((longlong)param_3 + 0x16a) = uVar13;

+        }

+        *(ushort *)(param_3 + 0x2d) = uVar13;

+        if (uVar14 != 0) {

+          memmove((void *)((ulonglong)*(ushort *)(param_3 + 0x23) + (longlong)param_3[0x2e]),

+                  (void *)((ulonglong)*(ushort *)param_3[0xf][0xb] + (longlong)param_3[0x10][9]),

+                  (ulonglong)uVar14);

+        }

+        uVar13 = uVar14 + *(short *)(param_3 + 0x23);

+        if (uVar13 < uVar14) {

+          uVar11 = 0xc0000095;

+          if ((((undefined **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+              ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 1) != 0)) &&

+             (WPP_GLOBAL_Control[0x29] != '\0')) {

+            WPP_SF_D(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x22,

+                     &WPP_ab16eb3fa49233b1d38e2865df17878b_Traceguids,0xc0000095);

+          }

+        }

+        else {

+          uVar14 = *(ushort *)(param_3 + 0x2d);

+          if (uVar14 < uVar13) {

+            uVar11 = 0xc0000095;

+            if ((((undefined **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+                ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 1) != 0)) &&

+               (WPP_GLOBAL_Control[0x29] != '\0')) {

+              WPP_SF_D(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x23,

+                       &WPP_ab16eb3fa49233b1d38e2865df17878b_Traceguids,0xc0000095);

+            }

+          }

+          else {

+            uStack_60 = (void *)(uVar12 + (longlong)uStack_60);

+            _Size = (undefined *)(ulonglong)(ushort)(uVar14 - uVar13);

+            memmove((void *)((ulonglong)uVar13 + (longlong)param_3[0x2e]),uStack_60,(size_t)_Size);

+            if ((((undefined **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+                ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+               (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+              uStack_60 = (void *)0x24;

+              _Size = &WPP_ab16eb3fa49233b1d38e2865df17878b_Traceguids;

+              WPP_SF_Z(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x24,

+                       &WPP_ab16eb3fa49233b1d38e2865df17878b_Traceguids,(wchar_t *)(param_3 + 0x2d))

+              ;

+            }

+            cVar6 = RxRemoveNameNetFcb((longlong)param_3,uStack_60,_Size);

+            ppplVar9 = param_3[0x24];

+            param_3[0x24] = (longlong ***)0x0;

+            if ((*(byte *)((longlong)param_3 + 0x163) & 2) != 0) {

+              ExFreePoolWithTag(param_3[0x2b],0);

+            }

+            *(byte *)((longlong)param_3 + 0x163) = *(byte *)((longlong)param_3 + 0x163) | 2;

+            uStack_60 = (void *)0x0;

+            *(wchar_t *)(param_3 + 0x2a) = wVar16;

+            *(wchar_t *)((longlong)param_3 + 0x152) = wVar17;

+            *(undefined2 *)((longlong)param_3 + 0x154) = uStack_64;

+            *(undefined2 *)((longlong)param_3 + 0x156) = uStack_62;

+            *(undefined2 *)(param_3 + 0x2b) = uVar18;

+            *(undefined2 *)((longlong)param_3 + 0x15a) = uVar19;

+            *(undefined2 *)((longlong)param_3 + 0x15c) = uVar20;

+            *(undefined2 *)((longlong)param_3 + 0x15e) = uVar21;

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

+              RxFcbTableInsertFcb((longlong)(param_3[0xf] + 0x25),(longlong)param_3,

+                                  param_3[0x10] != (longlong ***)0x0);

+            }

+            RxpFindOrCreateParentFcb(param_3);

+            if ((ppplVar9 != (longlong ***)0x0) && (param_3[0x24] == ppplVar9)) {

+              LOCK();

+              *(int *)(ppplVar9 + 0x13) = *(int *)(ppplVar9 + 0x13) + -1;

+              UNLOCK();

+              ppplVar9 = (longlong ***)0x0;

+            }

+            *param_5 = (longlong)ppplVar9;

+            if (*(longlong *)(*(longlong *)(*(longlong *)(param_1 + 0x38) + 0x188) + 0xb8) == 0) {

+              iVar7 = -0x3ffffffe;

+            }

+            else if ((*(uint *)(param_1 + 0x80) & 2) == 0) {

+              *(undefined8 *)(param_1 + 0xd0) = 0;

+              *(undefined8 *)(param_1 + 0xd8) = 0;

+              *(undefined8 *)(param_1 + 0xe0) = 0;

+              *(undefined8 *)(param_1 + 0xe8) = 0;

+              iVar7 = (**(code **)(*(longlong *)(*(longlong *)(param_1 + 0x38) + 0x188) + 0xb8))

+                                (param_3,param_3[0x24]);

+              if (-1 < iVar7) goto LAB_1;

+            }

+            else {

+              iVar7 = -0x3ffffee0;

+            }

+            if ((((undefined **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+                ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+               (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+              WPP_SF_D(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x25,

+                       &WPP_ab16eb3fa49233b1d38e2865df17878b_Traceguids,iVar7);

+            }

+          }

+        }

+      }

+    }

+    else {

+      uVar11 = 0xc0000120;

+    }

+  }

+LAB_1:

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

+    ExFreePoolWithTag(local_res10,0);

+  }

+LAB_0:

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

+    ExFreePoolWithTag(uStack_60,0);

+  }

   if ((((undefined **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

-      ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x100) != 0)) && (1 < (byte)WPP_GLOBAL_Control[0x29])

-     ) {

-    WPP_SF_q(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x4c,

-             &WPP_60b5a8f8ea003f1671eaaace2cafc76a_Traceguids,param_1);

-  }

-  uVar1 = func_0x00014006bca0(param_1,0);

-  return uVar1;

+      ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) && (1 < (byte)WPP_GLOBAL_Control[0x29]))

+  {

+    WPP_SF_Ld(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x26,

+              &WPP_ab16eb3fa49233b1d38e2865df17878b_Traceguids,(int)uVar11);

+  }

+  return uVar11;

 }
```

## `ComputeFinalCopyChunkDestinationEndingVbo`  (modified)

```diff
--- ComputeFinalCopyChunkDestinationEndingVbo
+++ ComputeFinalCopyChunkDestinationEndingVbo
@@ -1,24 +1,83 @@
-

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

 

 undefined8

 ComputeFinalCopyChunkDestinationEndingVbo

           (longlong param_1,uint param_2,uint *param_3,longlong *param_4)

 

 {

-  code *in_RAX;

-  undefined8 uVar1;

-  undefined4 in_register_00000014;

-  undefined1 *puStack0000000000000028;

-  undefined8 uStack0000000000000030;

-  longlong lStack0000000000000038;

-  undefined8 uStack0000000000000040;

+  uint *puVar1;

+  uint uVar2;

+  ulonglong uVar3;

+  longlong lVar4;

+  longlong *plVar5;

+  longlong lVar6;

+  uint uVar7;

   

-  uStack0000000000000030 = CONCAT44(in_register_00000014,param_2);

-  puStack0000000000000028 = &stack0x000000b8;

-  lStack0000000000000038 = param_1;

-  uStack0000000000000040 = uStack0000000000000030;

-  uVar1 = (*in_RAX)();

-  return uVar1;

+  uVar3 = Feature_255744314__private_IsEnabledDeviceUsageNoInline();

+  if ((int)uVar3 == 0) {

+    if (param_2 < *param_3) {

+      return 0xc00000c3;

+    }

+    *param_4 = 0;

+    uVar3 = 0;

+    lVar6 = 0;

+    uVar2 = 0;

+    if (*param_3 != 0) {

+      lVar6 = 0;

+      do {

+        lVar4 = (ulonglong)*(uint *)(param_1 + 0x10 + uVar3 * 0x18) +

+                *(longlong *)(param_1 + 8 + uVar3 * 0x18);

+        if (lVar6 <= lVar4) {

+          lVar6 = lVar4;

+        }

+        uVar7 = (int)uVar3 + 1;

+        uVar3 = (ulonglong)uVar7;

+        *param_4 = lVar6;

+        uVar2 = *param_3;

+      } while (uVar7 < uVar2);

+    }

+    if (param_2 <= uVar2) {

+      return 0;

+    }

+    if (param_3[1] == 0) {

+      return 0;

+    }

+    lVar4 = *(longlong *)(param_1 + 8 + (ulonglong)uVar2 * 0x18) + (ulonglong)param_3[1];

+  }

+  else {

+    uVar2 = *param_3;

+    uVar7 = param_3[1];

+    if (param_2 < uVar2) {

+      return 0xc00000c3;

+    }

+    *param_4 = 0;

+    lVar6 = 0;

+    if (uVar2 != 0) {

+      lVar6 = 0;

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

+      uVar3 = (ulonglong)uVar2;

+      do {

+        puVar1 = (uint *)(plVar5 + 1);

+        lVar4 = *plVar5;

+        plVar5 = plVar5 + 3;

+        if (lVar6 <= (longlong)((ulonglong)*puVar1 + lVar4)) {

+          lVar6 = (ulonglong)*puVar1 + lVar4;

+        }

+        *param_4 = lVar6;

+        uVar3 = uVar3 - 1;

+      } while (uVar3 != 0);

+    }

+    if (param_2 <= uVar2) {

+      return 0;

+    }

+    if (uVar7 == 0) {

+      return 0;

+    }

+    lVar4 = *(longlong *)(param_1 + 8 + (ulonglong)uVar2 * 0x18) + (ulonglong)uVar7;

+  }

+  if (lVar6 <= lVar4) {

+    lVar6 = lVar4;

+  }

+  *param_4 = lVar6;

+  return 0;

 }
```
