# CVE-2026-62766 — ksecpkg.sys patch diff

`ksecpkg.sys` 10.0.26100.8875 -> 10.0.26100.9168 (ghidriff).

## `KerbSealMessage`  (modified)

```diff
--- KerbSealMessage
+++ KerbSealMessage
@@ -1,19 +1,243 @@
 

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

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

+/* long __cdecl KerbSealMessage(struct _KERB_KERNEL_CONTEXT * __ptr64,unsigned long,struct

+   _SecBufferDesc * __ptr64,unsigned long) */

 

 long __cdecl

 KerbSealMessage(_KERB_KERNEL_CONTEXT *param_1,ulong param_2,_SecBufferDesc *param_3,ulong param_4)

 

 {

-  char *pcVar1;

-  char in_AL;

-  undefined7 in_register_00000001;

+  uint uVar1;

+  bool bVar2;

+  int iVar3;

+  ulonglong uVar4;

+  uint uVar5;

+  undefined1 *puVar6;

+  uint uVar7;

+  uint *puVar8;

+  int iVar9;

+  _SecBufferDesc *p_Var10;

+  ulonglong *puVar11;

+  Kerb3961PolicyType KVar12;

+  uint uVar13;

+  uint *puVar14;

+  uint *puVar15;

+  uint *puVar16;

+  uint *puVar17;

+  bool local_res8 [8];

+  ulong local_res10;

+  ulonglong local_b8;

+  void *local_b0;

+  int local_a8;

+  ulonglong local_a0;

+  KerberosCryptoPolicy *local_98;

+  longlong local_90;

+  longlong lStack_88;

+  undefined8 local_80;

+  ulonglong local_78;

+  ulonglong uStack_70;

+  ulonglong local_68;

+  longlong local_60;

+  EncryptionAlgorithm *local_58;

+  uchar *local_50;

+  longlong local_48;

   

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

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

-  pcVar1 = (char *)(CONCAT71(in_register_00000001,in_AL) + -0x7f);

-  *pcVar1 = *pcVar1 + (char)param_1;

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

-  halt_baddata();

+  p_Var10 = param_3;

+  local_res10 = param_2;

+  KerberosCryptoPolicy::FromKerberosKey

+            ((_KERB_ENCRYPTION_KEY *)&local_98,(bool)((char)param_1 + 'p'),SUB81(param_3,0),param_4)

+  ;

+  if (local_98 == (KerberosCryptoPolicy *)0x0) {

+    utl::unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>::

+    ~unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>

+              ((unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_> *)

+               &local_98);

+    return -0x3fffff66;

+  }

+  local_58 = KerberosCryptoPolicy::SelectEncryptionAlgorithm

+                       (local_98,(-(uint)((*(uint *)(param_1 + 0x9c) & 4) != 0) & 0xfffffffe) + 0x18

+                        ,(KdcPrincipalKeyState)p_Var10);

+  if (local_58 == (EncryptionAlgorithm *)0x0) {

+    iVar3 = -0x3ffffd03;

+    goto LAB_0;

+  }

+  local_80 = 0xffffffffffffffff;

+  local_90 = -1;

+  lStack_88 = -1;

+  bVar2 = utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::reserve

+                    ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_90

+                     ,(ulonglong)*(uint *)(param_3 + 4));

+  if (!bVar2) {

+    utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

+              ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_90);

+    iVar3 = -0x3fffff66;

+    goto LAB_0;

+  }

+  uVar5 = 0;

+  local_68 = 0;

+  if (*(int *)(param_3 + 4) != 0) {

+    iVar9 = 1;

+    local_60 = 0;

+    puVar14 = (uint *)0x0;

+    puVar16 = (uint *)0x0;

+    do {

+      puVar8 = (uint *)(*(longlong *)(param_3 + 8) + local_60);

+      uVar7 = puVar8[1];

+      if ((uVar7 & 0x90000000) == 0x90000000) goto LAB_1;

+      puVar15 = puVar8;

+      puVar17 = puVar16;

+      if ((((uVar7 & 0xfffffff) != 2) &&

+          (puVar15 = puVar14, puVar17 = puVar8, (uVar7 & 0xfffffff) != 9)) &&

+         (puVar17 = puVar16, -1 < (int)uVar7)) {

+        local_50 = *(uchar **)(puVar8 + 2);

+        local_78 = (ulonglong)*puVar8;

+        local_res8[0] = (bool)(~(byte)(uVar7 >> 0x1c) & 1);

+        utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::

+        emplace_back<unsigned___int64,unsigned_char*___ptr64,bool,0>

+                  ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_90,

+                   &local_78,&local_50,local_res8);

+        bVar2 = *puVar8 + uVar5 < uVar5;

+        uVar5 = *puVar8 + uVar5;

+        if (bVar2) goto LAB_2;

+      }

+      local_68 = local_68 + 1;

+      local_60 = local_60 + 0x10;

+      puVar14 = puVar15;

+      puVar16 = puVar17;

+    } while (local_68 < *(uint *)(param_3 + 4));

+    if (puVar15 != (uint *)0x0) {

+      if (((*(uint *)(param_1 + 0x98) >> 10 & 1) == 0) &&

+         ((*(uint *)(param_1 + 0x98) & 0x1000c) != 0x10000)) {

+        bVar2 = false;

+      }

+      else {

+        bVar2 = true;

+      }

+      local_a0 = 0;

+      uVar4 = Feature_AesSha2__private_IsEnabledDeviceUsageNoInline();

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

+        puVar11 = &local_a0;

+      }

+      else {

+        puVar11 = (ulonglong *)(-(ulonglong)(puVar17 != (uint *)0x0) & (ulonglong)&local_a0);

+      }

+      local_78 = (ulonglong)*(uint *)(param_1 + 0x78);

+      uStack_70 = *(ulonglong *)(param_1 + 0x80);

+      uVar4 = (ulonglong)param_4;

+      if (!bVar2) {

+        uVar4 = *(ulonglong *)(param_1 + 0x88);

+      }

+      local_48 = local_90;

+      local_50 = (uchar *)((lStack_88 - local_90 >> 3) * -0x5555555555555555);

+      (**(code **)(*(longlong *)local_58 + 0x120))

+                (local_58,&local_b8,&local_50,uVar4,local_res10,&local_78,

+                 ~(byte)(*(uint *)(param_1 + 0x9c) >> 2) & 1,

+                 (byte)(*(uint *)(param_1 + 0x9c) >> 10) & 1,puVar11);

+      KVar12 = (Kerb3961PolicyType)uVar4;

+      iVar3 = local_a8;

+      if (local_a8 < 0) {

+LAB_3:

+        Kerb3961::OwnedBinary::~OwnedBinary((OwnedBinary *)&local_b8);

+        utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

+                  ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_90);

+      }

+      else {

+        if (!bVar2) {

+          *(longlong *)(param_1 + 0x88) = *(longlong *)(param_1 + 0x88) + 1;

+        }

+        uVar7 = uVar5;

+        if (puVar17 == (uint *)0x0) {

+LAB_4:

+          local_res8[0] = false;

+          iVar3 = KerberosCryptoPolicy::CipherHasAttribute

+                            (*(long *)(param_1 + 0x70),8,local_res8,KVar12);

+          if (iVar3 < 0) goto LAB_3;

+          uVar5 = (uint)local_b8;

+          if (local_res8[0] == false) {

+            if (local_b8 <= *puVar15) {

+              *puVar15 = uVar5;

+              puVar6 = *(undefined1 **)(puVar15 + 2);

+LAB_5:

+              memmove(puVar6,local_b0,local_b8);

+              Kerb3961::OwnedBinary::~OwnedBinary((OwnedBinary *)&local_b8);

+              utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

+                        ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)

+                         &local_90);

+              utl::unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>::

+              ~unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>

+                        ((unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>

+                          *)&local_98);

+              return 0;

+            }

+          }

+          else {

+            puVar11 = (ulonglong *)&DAT_6;

+            if ((*(uint *)(param_1 + 0x9c) & 0x10) == 0) {

+              puVar11 = (ulonglong *)&DAT_7;

+            }

+            uVar13 = uVar5;

+            if (((*(uint *)(param_1 + 0x98) & 0x600) == 0) &&

+               (uVar13 = uVar5 + uVar7, uVar5 + uVar7 < uVar7)) goto LAB_8;

+            uVar7 = (int)*puVar11 + uVar13;

+            uVar1 = 0x1f;

+            if (uVar7 != 0) {

+              for (; uVar7 >> uVar1 == 0; uVar1 = uVar1 - 1) {

+              }

+            }

+            if ((uVar7 != 0) && (6 < uVar1)) {

+              iVar9 = (uVar1 >> 3) + 2;

+            }

+            uVar5 = (int)*puVar11 + 1 + iVar9 + uVar5;

+            if (uVar5 <= *puVar15) {

+              puVar6 = *(undefined1 **)(puVar15 + 2);

+              *puVar15 = uVar5;

+              local_78 = *puVar11;

+              uStack_70 = puVar11[1];

+              uVar5 = PutAsn1HeaderInMessage((uint *)&local_78,uVar13,puVar6);

+              puVar6 = puVar6 + uVar5;

+              goto LAB_5;

+            }

+          }

+        }

+        else {

+          if (local_a0 == 0) {

+            *puVar17 = 0;

+LAB_9:

+            uVar7 = *puVar17 + uVar5;

+            if (uVar5 <= uVar7) goto LAB_4;

+LAB_8:

+            Kerb3961::OwnedBinary::~OwnedBinary((OwnedBinary *)&local_b8);

+LAB_2:

+            utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

+                      ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)

+                       &local_90);

+            iVar3 = -0x3fffff6b;

+            goto LAB_0;

+          }

+          if (local_a0 <= *puVar17) {

+            local_b8 = local_b8 - local_a0;

+            *puVar17 = (uint)local_a0;

+            memmove(*(void **)(puVar17 + 2),(void *)((longlong)local_b0 + local_b8),local_a0);

+            goto LAB_9;

+          }

+        }

+        Kerb3961::OwnedBinary::~OwnedBinary((OwnedBinary *)&local_b8);

+        utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

+                  ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_90);

+        iVar3 = -0x3fffffdd;

+      }

+      goto LAB_0;

+    }

+  }

+LAB_1:

+  utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

+            ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_90);

+  iVar3 = -0x7ff6fcf8;

+LAB_0:

+  utl::unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>::

+  ~unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>

+            ((unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_> *)

+             &local_98);

+  return iVar3;

 }
```

## `KerbSealMessage`  (modified)

```diff
--- KerbSealMessage
+++ KerbUnsealMessage
@@ -1,243 +1,336 @@
 

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

-/* long __cdecl KerbSealMessage(struct _KERB_KERNEL_CONTEXT * __ptr64,unsigned long,struct

-   _SecBufferDesc * __ptr64,unsigned long) */

+/* long __cdecl KerbUnsealMessage(struct _KERB_KERNEL_CONTEXT * __ptr64,struct _SecBufferDesc *

+   __ptr64,unsigned long,unsigned long * __ptr64) */

 

 long __cdecl

-KerbSealMessage(_KERB_KERNEL_CONTEXT *param_1,ulong param_2,_SecBufferDesc *param_3,ulong param_4)

+KerbUnsealMessage(_KERB_KERNEL_CONTEXT *param_1,_SecBufferDesc *param_2,ulong param_3,ulong *param_4

+                 )

 

 {

-  uint uVar1;

-  bool bVar2;

+  bool bVar1;

+  long lVar2;

   int iVar3;

   ulonglong uVar4;

   uint uVar5;

-  undefined1 *puVar6;

+  ulonglong *puVar6;

   uint uVar7;

-  uint *puVar8;

-  int iVar9;

-  _SecBufferDesc *p_Var10;

-  ulonglong *puVar11;

-  Kerb3961PolicyType KVar12;

-  uint uVar13;

-  uint *puVar14;

-  uint *puVar15;

-  uint *puVar16;

-  uint *puVar17;

-  bool local_res8 [8];

-  ulong local_res10;

-  ulonglong local_b8;

-  void *local_b0;

-  int local_a8;

+  uint uVar8;

+  undefined4 *puVar9;

+  longlong lVar10;

+  undefined **ppuVar11;

+  void *_Dst;

+  EncryptionAlgorithm *pEVar12;

+  KdcPrincipalKeyState KVar13;

+  bool *pbVar14;

+  Kerb3961PolicyType KVar15;

+  ulong *puVar16;

+  bool *pbVar17;

+  ulonglong *puVar18;

+  uchar **ppuVar19;

+  ulonglong *puVar20;

+  ulonglong *puVar21;

+  EncryptionAlgorithm *pEVar22;

+  ulong uVar23;

+  char *pcVar24;

+  ulonglong *puVar25;

+  ulonglong *puVar26;

+  bool local_e8 [8];

+  longlong local_e0;

+  longlong lStack_d8;

+  undefined8 local_d0;

+  KerberosCryptoPolicy *local_c8;

+  ulonglong local_c0;

+  char *pcStack_b8;

+  EncryptionAlgorithm *local_b0;

+  undefined8 local_a8;

   ulonglong local_a0;

-  KerberosCryptoPolicy *local_98;

-  longlong local_90;

-  longlong lStack_88;

-  undefined8 local_80;

-  ulonglong local_78;

-  ulonglong uStack_70;

-  ulonglong local_68;

-  longlong local_60;

-  EncryptionAlgorithm *local_58;

-  uchar *local_50;

-  longlong local_48;

+  char *local_98;

+  uchar *local_90;

+  longlong local_88;

+  ulonglong local_80;

+  void *local_78;

+  int local_70;

+  EncryptionAlgorithm *local_68;

+  ulong local_60;

+  uchar *local_58;

+  longlong local_50;

+  ulonglong local_48;

+  undefined8 local_40;

   

-  p_Var10 = param_3;

-  local_res10 = param_2;

+  puVar16 = param_4;

+  KVar13 = param_3;

+  uVar4 = Feature_AesSha2__private_IsEnabledDeviceUsageNoInline();

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

+    lVar2 = KerbUnsealMessage_Old((longlong)param_1,(longlong)param_2,param_3,(bool *)param_4);

+    return lVar2;

+  }

   KerberosCryptoPolicy::FromKerberosKey

-            ((_KERB_ENCRYPTION_KEY *)&local_98,(bool)((char)param_1 + 'p'),SUB81(param_3,0),param_4)

-  ;

-  if (local_98 == (KerberosCryptoPolicy *)0x0) {

+            ((_KERB_ENCRYPTION_KEY *)&local_c8,(bool)((char)param_1 + 'p'),SUB41(KVar13,0),

+             (Kerb3961PolicyType)puVar16);

+  if (local_c8 == (KerberosCryptoPolicy *)0x0) {

     utl::unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>::

     ~unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>

               ((unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_> *)

-               &local_98);

+               &local_c8);

     return -0x3fffff66;

   }

-  local_58 = KerberosCryptoPolicy::SelectEncryptionAlgorithm

-                       (local_98,(-(uint)((*(uint *)(param_1 + 0x9c) & 4) != 0) & 0xfffffffe) + 0x18

-                        ,(KdcPrincipalKeyState)p_Var10);

-  if (local_58 == (EncryptionAlgorithm *)0x0) {

-    iVar3 = -0x3ffffd03;

+  local_b0 = KerberosCryptoPolicy::SelectEncryptionAlgorithm

+                       (local_c8,(-(uint)((*(uint *)(param_1 + 0x9c) & 4) != 0) & 2) + 0x16,KVar13);

+  if (local_b0 == (EncryptionAlgorithm *)0x0) {

+    lVar2 = -0x3ffffd03;

     goto LAB_0;

   }

-  local_80 = 0xffffffffffffffff;

-  local_90 = -1;

-  lStack_88 = -1;

-  bVar2 = utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::reserve

-                    ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_90

-                     ,(ulonglong)*(uint *)(param_3 + 4));

-  if (!bVar2) {

+  pbVar17 = (bool *)(ulonglong)*(uint *)(param_2 + 4);

+  puVar18 = (ulonglong *)0x0;

+  pbVar14 = (bool *)0x0;

+  if (pbVar17 == (bool *)0x0) {

+LAB_1:

+    lVar2 = -0x7ff6fcf8;

+    goto LAB_0;

+  }

+  puVar6 = *(ulonglong **)(param_2 + 8);

+  puVar20 = (ulonglong *)0x0;

+  puVar25 = (ulonglong *)0x0;

+  do {

+    if ((*(uint *)((longlong)puVar6 + 4) & 0x90000000) == 0x90000000) goto LAB_1;

+    uVar7 = *(uint *)((longlong)puVar6 + 4) & 0xfffffff;

+    puVar21 = puVar6;

+    puVar26 = puVar25;

+    if (((uVar7 != 2) && (puVar21 = puVar20, puVar26 = puVar6, uVar7 != 10)) &&

+       (puVar26 = puVar25, uVar7 == 9)) {

+      puVar18 = puVar6;

+    }

+    pbVar14 = pbVar14 + 1;

+    puVar6 = puVar6 + 2;

+    puVar20 = puVar21;

+    puVar25 = puVar26;

+  } while (pbVar14 < pbVar17);

+  if (puVar21 == (ulonglong *)0x0) {

+    if (puVar26 == (ulonglong *)0x0) goto LAB_1;

+  }

+  else if (puVar26 != (ulonglong *)0x0) {

+    lVar2 = -0x3ffffff3;

+    goto LAB_0;

+  }

+  local_d0 = 0xffffffffffffffff;

+  local_e0 = -1;

+  lStack_d8 = -1;

+  bVar1 = utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::reserve

+                    ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_e0

+                     ,(__uint64)pbVar17);

+  KVar15 = (Kerb3961PolicyType)pbVar17;

+  if (!bVar1) {

     utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

-              ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_90);

-    iVar3 = -0x3fffff66;

+              ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_e0);

+    lVar2 = -0x3fffff66;

     goto LAB_0;

   }

-  uVar5 = 0;

-  local_68 = 0;

-  if (*(int *)(param_3 + 4) != 0) {

-    iVar9 = 1;

-    local_60 = 0;

-    puVar14 = (uint *)0x0;

-    puVar16 = (uint *)0x0;

-    do {

-      puVar8 = (uint *)(*(longlong *)(param_3 + 8) + local_60);

-      uVar7 = puVar8[1];

-      if ((uVar7 & 0x90000000) == 0x90000000) goto LAB_1;

-      puVar15 = puVar8;

-      puVar17 = puVar16;

-      if ((((uVar7 & 0xfffffff) != 2) &&

-          (puVar15 = puVar14, puVar17 = puVar8, (uVar7 & 0xfffffff) != 9)) &&

-         (puVar17 = puVar16, -1 < (int)uVar7)) {

-        local_50 = *(uchar **)(puVar8 + 2);

-        local_78 = (ulonglong)*puVar8;

-        local_res8[0] = (bool)(~(byte)(uVar7 >> 0x1c) & 1);

-        utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::

-        emplace_back<unsigned___int64,unsigned_char*___ptr64,bool,0>

-                  ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_90,

-                   &local_78,&local_50,local_res8);

-        bVar2 = *puVar8 + uVar5 < uVar5;

-        uVar5 = *puVar8 + uVar5;

-        if (bVar2) goto LAB_2;

-      }

-      local_68 = local_68 + 1;

-      local_60 = local_60 + 0x10;

-      puVar14 = puVar15;

-      puVar16 = puVar17;

-    } while (local_68 < *(uint *)(param_3 + 4));

-    if (puVar15 != (uint *)0x0) {

-      if (((*(uint *)(param_1 + 0x98) >> 10 & 1) == 0) &&

-         ((*(uint *)(param_1 + 0x98) & 0x1000c) != 0x10000)) {

-        bVar2 = false;

+  uVar7 = 0;

+  if (puVar26 == (ulonglong *)0x0) {

+    local_a0 = 0;

+    if (*(int *)(param_2 + 4) != 0) {

+      lVar10 = 0;

+      do {

+        local_c0 = *(ulonglong *)(param_2 + 8);

+        uVar5 = *(uint *)(lVar10 + 4 + local_c0);

+        if ((((uVar5 & 0xfffffff) != 2) && ((uVar5 & 0xfffffff) != 9)) && (-1 < (int)uVar5)) {

+          pbVar17 = local_e8;

+          local_e8[0] = (bool)(~(byte)(uVar5 >> 0x1c) & 1);

+          local_58 = *(uchar **)(lVar10 + 8 + local_c0);

+          local_48 = (ulonglong)*(uint *)(lVar10 + local_c0);

+          utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::

+          emplace_back<unsigned___int64,unsigned_char*___ptr64,bool,0>

+                    ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_e0

+                     ,&local_48,&local_58,pbVar17);

+          uVar5 = *(int *)(lVar10 + local_c0) + uVar7;

+          bVar1 = uVar5 < uVar7;

+          uVar7 = uVar5;

+          if (bVar1) goto LAB_2;

+        }

+        KVar15 = (Kerb3961PolicyType)pbVar17;

+        local_a0 = local_a0 + 1;

+        lVar10 = lVar10 + 0x10;

+      } while (local_a0 < *(uint *)(param_2 + 4));

+    }

+    uVar5 = (uint)*puVar21 + uVar7;

+    if ((uVar5 < uVar7) ||

+       ((uVar7 = uVar5, puVar18 != (ulonglong *)0x0 &&

+        (uVar7 = (uint)*puVar18 + uVar5, uVar7 < uVar5)))) {

+LAB_2:

+      utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

+                ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_e0);

+      lVar2 = -0x3fffff6b;

+      goto LAB_0;

+    }

+  }

+  else {

+    uVar7 = (uint)*puVar26;

+  }

+  local_e8[0] = false;

+  lVar2 = KerberosCryptoPolicy::CipherHasAttribute(*(long *)(param_1 + 0x70),8,local_e8,KVar15);

+  if (-1 < lVar2) {

+    if (puVar26 != (ulonglong *)0x0) {

+      puVar21 = puVar26;

+    }

+    local_c0 = *puVar21;

+    pcVar24 = (char *)puVar21[1];

+    uVar5 = (uint)local_c0;

+    pcStack_b8 = pcVar24;

+    if ((local_e8[0] != false) &&

+       ((uVar7 = VerifyAsn1ApplicationHeaderLength(uVar7,(uint)local_c0,pcVar24), uVar7 != 0 ||

+        (uVar7 = VerifyAsn1ApplicationHeaderLength(uVar5,uVar5,pcVar24), uVar7 != 0)))) {

+      ppuVar11 = (undefined **)&DAT_3;

+      do {

+        uVar8 = *(uint *)ppuVar11;

+        if ((uVar8 <= uVar5 - uVar7) &&

+           (iVar3 = memcmp(pcVar24 + uVar7,ppuVar11[1],(ulonglong)uVar8), iVar3 == 0)) {

+          uVar5 = (uVar5 - uVar7) - uVar8;

+          pcVar24 = pcVar24 + uVar7 + uVar8;

+          if ((ppuVar11 != (undefined **)&DAT_4) ||

+             ((*(uint *)(param_1 + 0x9c) & 0x10) != 0)) goto LAB_5;

+          break;

+        }

+        ppuVar11 = ppuVar11 + 2;

+      } while (ppuVar11 != &Feature_Servicing_KsecpkgArgonSiloFix__private_requiresFeatures);

+LAB_6:

+      utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

+                ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_e0);

+      lVar2 = -0x7ff6fcf1;

+      goto LAB_0;

+    }

+LAB_5:

+    pEVar22 = local_b0;

+    uVar8 = *(uint *)(param_1 + 0x9c) & 0x400;

+    uVar7 = *(uint *)(param_1 + 0x9c) & 4;

+    local_90 = (uchar *)(ulonglong)*(uint *)(param_1 + 0x78);

+    lVar10 = *(longlong *)local_b0;

+    if (puVar26 == (ulonglong *)0x0) {

+      if (puVar18 == (ulonglong *)0x0) {

+        puVar6 = &local_48;

+        local_48 = 0;

+        local_40 = 0;

       }

       else {

-        bVar2 = true;

+        local_c0 = (ulonglong)(uint)*puVar18;

+        puVar6 = &local_c0;

+        pcStack_b8 = (char *)puVar18[1];

       }

-      local_a0 = 0;

-      uVar4 = Feature_AesSha2__private_IsEnabledDeviceUsageNoInline();

-      if ((int)uVar4 == 0) {

-        puVar11 = &local_a0;

-      }

-      else {

-        puVar11 = (ulonglong *)(-(ulonglong)(puVar17 != (uint *)0x0) & (ulonglong)&local_a0);

-      }

-      local_78 = (ulonglong)*(uint *)(param_1 + 0x78);

-      uStack_70 = *(ulonglong *)(param_1 + 0x80);

-      uVar4 = (ulonglong)param_4;

-      if (!bVar2) {

-        uVar4 = *(ulonglong *)(param_1 + 0x88);

-      }

-      local_48 = local_90;

-      local_50 = (uchar *)((lStack_88 - local_90 >> 3) * -0x5555555555555555);

-      (**(code **)(*(longlong *)local_58 + 0x120))

-                (local_58,&local_b8,&local_50,uVar4,local_res10,&local_78,

-                 ~(byte)(*(uint *)(param_1 + 0x9c) >> 2) & 1,

-                 (byte)(*(uint *)(param_1 + 0x9c) >> 10) & 1,puVar11);

-      KVar12 = (Kerb3961PolicyType)uVar4;

-      iVar3 = local_a8;

-      if (local_a8 < 0) {

-LAB_3:

-        Kerb3961::OwnedBinary::~OwnedBinary((OwnedBinary *)&local_b8);

-        utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

-                  ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_90);

-      }

-      else {

-        if (!bVar2) {

-          *(longlong *)(param_1 + 0x88) = *(longlong *)(param_1 + 0x88) + 1;

-        }

-        uVar7 = uVar5;

-        if (puVar17 == (uint *)0x0) {

-LAB_4:

-          local_res8[0] = false;

-          iVar3 = KerberosCryptoPolicy::CipherHasAttribute

-                            (*(long *)(param_1 + 0x70),8,local_res8,KVar12);

-          if (iVar3 < 0) goto LAB_3;

-          uVar5 = (uint)local_b8;

-          if (local_res8[0] == false) {

-            if (local_b8 <= *puVar15) {

-              *puVar15 = uVar5;

-              puVar6 = *(undefined1 **)(puVar15 + 2);

-LAB_5:

-              memmove(puVar6,local_b0,local_b8);

-              Kerb3961::OwnedBinary::~OwnedBinary((OwnedBinary *)&local_b8);

-              utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

-                        ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)

-                         &local_90);

-              utl::unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>::

-              ~unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>

-                        ((unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>

-                          *)&local_98);

-              return 0;

+      puVar18 = &local_a0;

+      local_a0 = (ulonglong)uVar5;

+      local_88 = local_e0;

+      local_98 = pcVar24;

+      local_58 = local_90;

+      local_90 = (uchar *)((lStack_d8 - local_e0 >> 3) * -0x5555555555555555);

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

+      (**(code **)(lVar10 + 0x128))

+                (local_b0,&local_b0,&local_90,puVar18,puVar6,&local_58,uVar7 == 0,uVar8 != 0);

+      KVar15 = (Kerb3961PolicyType)puVar18;

+      lVar2 = local_a8._4_4_;

+      if (-1 < (longlong)local_a8) {

+        pEVar22 = local_b0;

+        uVar23 = (ulong)local_a8;

+LAB_7:

+        uVar7 = *(uint *)(param_1 + 0x98);

+        if (((uVar7 >> 10 & 1) != 0) || (bVar1 = false, (uVar7 & 0x1000c) == 0x10000)) {

+          bVar1 = true;

+        }

+        if ((uVar7 & 0xc) == 0) goto LAB_8;

+        pEVar12 = (EncryptionAlgorithm *)(ulonglong)param_3;

+        if (bVar1 == false) {

+          pEVar12 = *(EncryptionAlgorithm **)(param_1 + 0x90);

+        }

+        local_e8[0] = false;

+        lVar2 = KerberosCryptoPolicy::CipherHasAttribute

+                          (*(long *)(param_1 + 0x70),0x10,local_e8,KVar15);

+        if (-1 < lVar2) {

+          if (local_e8[0] == false) {

+            if (pEVar22 == pEVar12) goto LAB_8;

+          }

+          else if ((int)pEVar22 == (int)pEVar12) {

+LAB_8:

+            if (bVar1 == false) {

+              *(longlong *)(param_1 + 0x90) = *(longlong *)(param_1 + 0x90) + 1;

             }

-          }

-          else {

-            puVar11 = (ulonglong *)&DAT_6;

-            if ((*(uint *)(param_1 + 0x9c) & 0x10) == 0) {

-              puVar11 = (ulonglong *)&DAT_7;

+            if (param_4 != (ulong *)0x0) {

+              *param_4 = uVar23;

             }

-            uVar13 = uVar5;

-            if (((*(uint *)(param_1 + 0x98) & 0x600) == 0) &&

-               (uVar13 = uVar5 + uVar7, uVar5 + uVar7 < uVar7)) goto LAB_8;

-            uVar7 = (int)*puVar11 + uVar13;

-            uVar1 = 0x1f;

-            if (uVar7 != 0) {

-              for (; uVar7 >> uVar1 == 0; uVar1 = uVar1 - 1) {

-              }

-            }

-            if ((uVar7 != 0) && (6 < uVar1)) {

-              iVar9 = (uVar1 >> 3) + 2;

-            }

-            uVar5 = (int)*puVar11 + 1 + iVar9 + uVar5;

-            if (uVar5 <= *puVar15) {

-              puVar6 = *(undefined1 **)(puVar15 + 2);

-              *puVar15 = uVar5;

-              local_78 = *puVar11;

-              uStack_70 = puVar11[1];

-              uVar5 = PutAsn1HeaderInMessage((uint *)&local_78,uVar13,puVar6);

-              puVar6 = puVar6 + uVar5;

-              goto LAB_5;

-            }

-          }

-        }

-        else {

-          if (local_a0 == 0) {

-            *puVar17 = 0;

-LAB_9:

-            uVar7 = *puVar17 + uVar5;

-            if (uVar5 <= uVar7) goto LAB_4;

-LAB_8:

-            Kerb3961::OwnedBinary::~OwnedBinary((OwnedBinary *)&local_b8);

-LAB_2:

             utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

                       ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)

-                       &local_90);

-            iVar3 = -0x3fffff6b;

-            goto LAB_0;

+                       &local_e0);

+            utl::unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>::

+            ~unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>

+                      ((unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>

+                        *)&local_c8);

+            return 0;

           }

-          if (local_a0 <= *puVar17) {

-            local_b8 = local_b8 - local_a0;

-            *puVar17 = (uint)local_a0;

-            memmove(*(void **)(puVar17 + 2),(void *)((longlong)local_b0 + local_b8),local_a0);

-            goto LAB_9;

+          utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

+                    ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_e0

+                    );

+          lVar2 = -0x7ff6fcf0;

+          goto LAB_0;

+        }

+      }

+    }

+    else {

+      local_b0 = (EncryptionAlgorithm *)(ulonglong)uVar5;

+      ppuVar19 = &local_90;

+      local_a8 = pcVar24;

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

+      (**(code **)(lVar10 + 0x108))(pEVar22,&local_80,&local_b0,ppuVar19,uVar7 == 0,uVar8 != 0);

+      KVar15 = (Kerb3961PolicyType)ppuVar19;

+      lVar2 = local_70;

+      if (-1 < local_70) {

+        if ((uint)*puVar26 < local_80) {

+          Kerb3961::OwnedBinary::~OwnedBinary((OwnedBinary *)&local_80);

+          utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

+                    ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_e0

+                    );

+          goto LAB_1;

+        }

+        _Dst = (void *)((puVar26[1] - local_80) + (ulonglong)(uint)*puVar26);

+        memmove(_Dst,local_78,local_80);

+        uVar4 = 0;

+        local_e8[0] = false;

+        lVar2 = KerberosCryptoPolicy::CipherHasAttribute

+                          (*(long *)(param_1 + 0x70),0x20,local_e8,KVar15);

+        if (-1 < lVar2) {

+          if (local_e8[0] != false) {

+            if ((local_80 == 0) || (*(char *)((longlong)local_78 + (local_80 - 1)) != '\x01')) {

+              Kerb3961::OwnedBinary::~OwnedBinary((OwnedBinary *)&local_80);

+              goto LAB_6;

+            }

+            local_80 = local_80 - 1;

           }

-        }

-        Kerb3961::OwnedBinary::~OwnedBinary((OwnedBinary *)&local_b8);

-        utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

-                  ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_90);

-        iVar3 = -0x3fffffdd;

+          KVar15 = *(Kerb3961PolicyType *)(param_2 + 4);

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

+            puVar9 = *(undefined4 **)(param_2 + 8);

+            do {

+              if ((puVar9[1] & 0xfffffff) == 1) {

+                *puVar9 = (int)local_80;

+                *(void **)(puVar9 + 2) = _Dst;

+                break;

+              }

+              uVar4 = uVar4 + 1;

+              puVar9 = puVar9 + 4;

+            } while (uVar4 < KVar15);

+          }

+          Kerb3961::OwnedBinary::~OwnedBinary((OwnedBinary *)&local_80);

+          pEVar22 = local_68;

+          uVar23 = local_60;

+          goto LAB_7;

+        }

       }

-      goto LAB_0;

-    }

-  }

-LAB_1:

+      Kerb3961::OwnedBinary::~OwnedBinary((OwnedBinary *)&local_80);

+    }

+  }

   utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit

-            ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_90);

-  iVar3 = -0x7ff6fcf8;

+            ((vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_> *)&local_e0);

 LAB_0:

   utl::unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>::

   ~unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>

             ((unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_> *)

-             &local_98);

-  return iVar3;

+             &local_c8);

+  return lVar2;

 }
```

## `KerbSpVerifySignature`  (modified)

```diff
--- KerbSpVerifySignature
+++ KerbSpVerifySignature
@@ -1,40 +1,36 @@
 

 long KerbSpVerifySignature(undefined8 param_1,_SecBufferDesc *param_2,ulong param_3,ulong *param_4)

 

 {

   bool bVar1;

   uint uVar2;

   long lVar3;

   _KERB_KERNEL_CONTEXT *p_Var4;

-  undefined8 unaff_RBX;

-  _SecBufferDesc *unaff_RBP;

-  ulong unaff_ESI;

-  ulong *unaff_RDI;

-  undefined4 in_register_00000084;

   

-  ExEnterCriticalRegionAndAcquireResourceExclusive

-            (param_1,param_2,CONCAT44(in_register_00000084,param_3));

   if (KerbCryptInitialized == '\0') {

-    uVar2 = LibAttach();

-    if (uVar2 != 0) {

-      KerbCryptInitialized = '\x01';

+    ExEnterCriticalRegionAndAcquireResourceExclusive(&KerbGlobalResource);

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

+      uVar2 = LibAttach();

+      if (uVar2 != 0) {

+        KerbCryptInitialized = '\x01';

+      }

     }

+    ExReleaseResourceAndLeaveCriticalRegion(&KerbGlobalResource);

   }

-  ExReleaseResourceAndLeaveCriticalRegion(&KerbGlobalResource);

-  p_Var4 = (_KERB_KERNEL_CONTEXT *)KerbReferenceContext(unaff_RBX,0);

+  p_Var4 = (_KERB_KERNEL_CONTEXT *)KerbReferenceContext(param_1,0);

   if (p_Var4 == (_KERB_KERNEL_CONTEXT *)0x0) {

     lVar3 = -0x3ffffff8;

   }

   else {

     bVar1 = KerbShouldUseLegacySspi(*(long *)(p_Var4 + 0x70));

     if (bVar1) {

-      lVar3 = KerbVerifySignatureOld(p_Var4,unaff_RBP,unaff_ESI,unaff_RDI);

+      lVar3 = KerbVerifySignatureOld(p_Var4,param_2,param_3,param_4);

     }

     else {

-      lVar3 = KerbVerifySignature(p_Var4,unaff_RBP,unaff_ESI,unaff_RDI);

+      lVar3 = KerbVerifySignature(p_Var4,param_2,param_3,param_4);

     }

     KerbDereferenceContext(p_Var4);

   }

   return lVar3;

 }
```

## `KerbSpUnsealMessage`  (modified)

```diff
--- KerbSpUnsealMessage
+++ KerbSpUnsealMessage
@@ -1,10 +1,36 @@
-

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

 

 long KerbSpUnsealMessage(undefined8 param_1,_SecBufferDesc *param_2,ulong param_3,ulong *param_4)

 

 {

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

-  halt_baddata();

+  bool bVar1;

+  uint uVar2;

+  long lVar3;

+  _KERB_KERNEL_CONTEXT *p_Var4;

+  

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

+    ExEnterCriticalRegionAndAcquireResourceExclusive(&KerbGlobalResource);

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

+      uVar2 = LibAttach();

+      if (uVar2 != 0) {

+        KerbCryptInitialized = '\x01';

+      }

+    }

+    ExReleaseResourceAndLeaveCriticalRegion(&KerbGlobalResource);

+  }

+  p_Var4 = (_KERB_KERNEL_CONTEXT *)KerbReferenceContext(param_1,0);

+  if (p_Var4 == (_KERB_KERNEL_CONTEXT *)0x0) {

+    lVar3 = -0x3ffffff8;

+  }

+  else {

+    bVar1 = KerbShouldUseLegacySspi(*(long *)(p_Var4 + 0x70));

+    if (bVar1) {

+      lVar3 = KerbUnsealMessageOld(p_Var4,param_2,param_3,param_4);

+    }

+    else {

+      lVar3 = KerbUnsealMessage(p_Var4,param_2,param_3,param_4);

+    }

+    KerbDereferenceContext(p_Var4);

+  }

+  return lVar3;

 }
```

## `Sha512WrapFinish`  (modified)

```diff
--- Sha512WrapFinish
+++ Sha512WrapFinish
@@ -1,12 +1,21 @@
 

 undefined8 Sha512WrapFinish(undefined8 *param_1)

 

 {

-  code *pcVar1;

-  undefined8 uVar2;

+  ulonglong uVar1;

+  undefined8 *puVar2;

   

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

-  uVar2 = (*pcVar1)();

-  return uVar2;

+  uVar1 = Feature_Servicing_CryptdllCodeQL__private_IsEnabledDeviceUsageNoInline();

+  puVar2 = (undefined8 *)*param_1;

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

+    *puVar2 = 0;

+    puVar2 = (undefined8 *)*param_1;

+  }

+  else {

+    *puVar2 = 0;

+  }

+  ExFreePoolWithTag(puVar2,0);

+  *param_1 = 0;

+  return 0;

 }
```

## `Feature_AesSha2__private_IsEnabledDeviceUsageNoInline`  (modified)

```diff
--- Feature_AesSha2__private_IsEnabledDeviceUsageNoInline
+++ KerberosCryptoPolicy::FromKerberosKey
@@ -1,17 +1,50 @@
 

-ulonglong Feature_AesSha2__private_IsEnabledDeviceUsageNoInline(void)

+/* public: static class utl::unique_ptr<class KerberosCryptoPolicy,struct utl::default_delete<class

+   KerberosCryptoPolicy> > __cdecl KerberosCryptoPolicy::FromKerberosKey(struct _KERB_ENCRYPTION_KEY

+   * __ptr64,bool,bool,enum Kerb3961PolicyType) */

+

+_KERB_ENCRYPTION_KEY * __cdecl

+KerberosCryptoPolicy::FromKerberosKey

+          (_KERB_ENCRYPTION_KEY *param_1,bool param_2,bool param_3,Kerb3961PolicyType param_4)

 

 {

-  ulonglong uVar1;

-  undefined8 local_res8;

+  undefined8 *puVar1;

+  longlong lVar2;

+  undefined7 in_register_00000011;

+  longlong local_res10;

+  unique_ptr<_KERB_ENCRYPTION_KEY,KerberosCryptoPolicy::EncryptionKeyDeleter> local_18 [8];

+  undefined8 local_10;

   

-  local_res8 = (ulonglong)Feature_AesSha2__private_featureState;

-  if ((Feature_AesSha2__private_featureState & 0x10) == 0) {

-    uVar1 = Feature_AesSha2__private_IsEnabledFallback(local_res8,3);

+  if (CONCAT71(in_register_00000011,param_2) == 0) {

+    *(ulonglong *)param_1 = *(ulonglong *)param_1 & CONCAT71(in_register_00000011,param_2);

   }

   else {

-    uVar1 = (ulonglong)(Feature_AesSha2__private_featureState & 1);

+    Create((Kerb3961PolicyType)&local_res10);

+    lVar2 = local_res10;

+    if (local_res10 == 0) {

+      *(undefined8 *)param_1 = 0;

+    }

+    else {

+      puVar1 = *(undefined8 **)(local_res10 + 0x70);

+      local_10 = 0;

+      local_18[0] = (unique_ptr<_KERB_ENCRYPTION_KEY,KerberosCryptoPolicy::EncryptionKeyDeleter>)0x0

+      ;

+      *(ulonglong *)(local_res10 + 0x70) = CONCAT71(in_register_00000011,param_2);

+      if ((puVar1 != (undefined8 *)0x0) && (*(char *)(local_res10 + 0x68) != '\0')) {

+        KerbFreeKey(puVar1);

+      }

+      *(undefined1 *)(local_res10 + 0x68) = 0;

+      utl::unique_ptr<_KERB_ENCRYPTION_KEY,KerberosCryptoPolicy::EncryptionKeyDeleter>::

+      ~unique_ptr<_KERB_ENCRYPTION_KEY,KerberosCryptoPolicy::EncryptionKeyDeleter>(local_18);

+      local_res10 = 0;

+      *(undefined1 *)(lVar2 + 8) = 1;

+      *(longlong *)param_1 = lVar2;

+    }

+    utl::unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>::

+    ~unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_>

+              ((unique_ptr<KerberosCryptoPolicy,utl::default_delete<KerberosCryptoPolicy>_> *)

+               &local_res10);

   }

-  return uVar1;

+  return param_1;

 }
```

## `KerbSpSealMessage`  (modified)

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

 long KerbSpSealMessage(undefined8 param_1,ulong param_2,_SecBufferDesc *param_3,ulong param_4)

 

 {

   bool bVar1;

   uint uVar2;

   long lVar3;

   _KERB_KERNEL_CONTEXT *p_Var4;

   

   if (KerbCryptInitialized == '\0') {

     ExEnterCriticalRegionAndAcquireResourceExclusive(&KerbGlobalResource);

     if (KerbCryptInitialized == '\0') {

       uVar2 = LibAttach();

       if (uVar2 != 0) {

         KerbCryptInitialized = '\x01';

       }

     }

     ExReleaseResourceAndLeaveCriticalRegion(&KerbGlobalResource);

   }

   p_Var4 = (_KERB_KERNEL_CONTEXT *)KerbReferenceContext(param_1,0);

   if (p_Var4 == (_KERB_KERNEL_CONTEXT *)0x0) {

     lVar3 = -0x3ffffff8;

   }

   else {

     bVar1 = KerbShouldUseLegacySspi(*(long *)(p_Var4 + 0x70));

     if (bVar1) {

-      lVar3 = KerbSealMessageOld(p_Var4,param_2,(_SecBufferDesc *)param_3,param_4);

+      lVar3 = KerbSealMessageOld(p_Var4,param_2,param_3,param_4);

     }

     else {

-      lVar3 = KerbSealMessage(p_Var4,param_2,(_SecBufferDesc *)param_3,param_4);

+      lVar3 = KerbSealMessage(p_Var4,param_2,param_3,param_4);

     }

     KerbDereferenceContext(p_Var4);

   }

   return lVar3;

 }
```

## `utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit`  (modified)

```diff
--- utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit
+++ KerberosCryptoPolicy::CipherHasAttribute
@@ -1,2 +1,2 @@
-Failed to decompile ksecpkg.sys - .ProgramDB utl::vector<Kerb3961::WrapBuffer,utl::allocator<Kerb3961::WrapBuffer>_>::_Uninit : Error: Decompile error: 
+Failed to decompile ksecpkg.sys - .ProgramDB KerberosCryptoPolicy::CipherHasAttribute : Error: Decompile error: 
 Marshaling error: Did not see expected closing element
```

## `KerbSpMakeSignature`  (modified)

```diff
--- KerbSpMakeSignature
+++ KerbSpMakeSignature
@@ -1,2 +1,36 @@
-Failed to decompile ksecpkg.sys - .ProgramDB KerbSpMakeSignature : Error: Decompile error: 
-Low-level Error: DuplicateFunctionError, but could not recover original symbol+

+long KerbSpMakeSignature(undefined8 param_1,ulong param_2,_SecBufferDesc *param_3,ulong param_4)

+

+{

+  bool bVar1;

+  uint uVar2;

+  long lVar3;

+  _KERB_KERNEL_CONTEXT *p_Var4;

+  

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

+    ExEnterCriticalRegionAndAcquireResourceExclusive(&KerbGlobalResource);

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

+      uVar2 = LibAttach();

+      if (uVar2 != 0) {

+        KerbCryptInitialized = '\x01';

+      }

+    }

+    ExReleaseResourceAndLeaveCriticalRegion(&KerbGlobalResource);

+  }

+  p_Var4 = (_KERB_KERNEL_CONTEXT *)KerbReferenceContext(param_1,0);

+  if (p_Var4 == (_KERB_KERNEL_CONTEXT *)0x0) {

+    lVar3 = -0x3ffffff8;

+  }

+  else {

+    bVar1 = KerbShouldUseLegacySspi(*(long *)(p_Var4 + 0x70));

+    if (bVar1) {

+      lVar3 = KerbMakeSignatureOld(p_Var4,param_2,param_3,param_4);

+    }

+    else {

+      lVar3 = KerbMakeSignature(p_Var4,param_2,param_3,param_4);

+    }

+    KerbDereferenceContext(p_Var4);

+  }

+  return lVar3;

+}

+
```

## `KerbQueryContextAttributes`  (modified)

```diff
--- KerbQueryContextAttributes
+++ KerbQueryContextAttributes
@@ -1,2 +1,347 @@
-Failed to decompile ksecpkg.sys - .ProgramDB KerbQueryContextAttributes : Error: Decompile error: 
-Low-level Error: DuplicateFunctionError, but could not recover original symbol+

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

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

+

+ulonglong KerbQueryContextAttributes(undefined8 param_1,uint param_2,ulong *param_3)

+

+{

+  ulong *puVar1;

+  undefined8 *puVar2;

+  bool bVar3;

+  uint uVar4;

+  uint uVar5;

+  ulong uVar6;

+  _KERB_KERNEL_CONTEXT *p_Var7;

+  void *pvVar8;

+  undefined1 *puVar9;

+  ulonglong uVar10;

+  longlong lVar11;

+  ulong uVar12;

+  gss_OID_desc_struct *pgVar13;

+  ulonglong uVar14;

+  char cVar15;

+  __uint64 *p_Var16;

+  ulong uVar17;

+  __uint64 local_res20;

+  Kerb3961PolicyType in_stack_ffffffffffffffb0;

+  __uint64 local_48;

+  __uint64 local_40 [3];

+  

+  local_res20 = local_res20 & 0xffffffff00000000;

+  uVar14 = 0;

+  local_40[0] = 0;

+  uVar17 = 1;

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

+    ExEnterCriticalRegionAndAcquireResourceExclusive(&KerbGlobalResource);

+    if ((KerbCryptInitialized == '\0') && (uVar4 = LibAttach(), uVar4 != 0)) {

+      KerbCryptInitialized = '\x01';

+    }

+    ExReleaseResourceAndLeaveCriticalRegion(&KerbGlobalResource);

+  }

+  p_Var7 = (_KERB_KERNEL_CONTEXT *)KerbReferenceContext(param_1,0);

+  uVar6 = 0;

+  uVar10 = uVar14;

+  if (p_Var7 == (_KERB_KERNEL_CONTEXT *)0x0) {

+    if ((param_2 - 10 & 0xfffffffd) != 0) {

+      return 0xc0000008;

+    }

+LAB_0:

+    uVar10 = Feature_3629870394__private_IsEnabledDeviceUsageNoInline();

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

+      lVar11 = (*_KspKernelFunctions)(0x62);

+    }

+    else {

+      lVar11 = KSecAllocateContextBuffer();

+    }

+    *(longlong *)param_3 = lVar11;

+    if (lVar11 == 0) {

+LAB_1:

+      uVar10 = 0xc000009a;

+    }

+    else {

+      *(longlong *)(lVar11 + 0x10) = lVar11 + 0x20;

+      *(longlong *)(*(longlong *)param_3 + 0x18) = *(longlong *)(*(longlong *)param_3 + 0x10) + 0x12

+      ;

+      puVar2 = *(undefined8 **)(*(longlong *)param_3 + 0x10);

+      *puVar2 = 0x6200720065004b;

+      puVar2[1] = 0x73006f00720065;

+      *(undefined2 *)(puVar2 + 2) = 0;

+      builtin_wcsncpy(*(wchar_t **)(*(longlong *)param_3 + 0x18),L"Microsoft Kerberos V1.0",0x18);

+      *(undefined2 *)(*(longlong *)param_3 + 4) = 1;

+      *(undefined2 *)(*(longlong *)param_3 + 6) = 0x10;

+      **(undefined4 **)param_3 = 0x833bbf;

+      *(ulong *)(*(longlong *)param_3 + 8) = KerbMaxTokenSize;

+      uVar10 = 0;

+      if (param_2 == 0xc) {

+        param_3[2] = 0;

+        uVar10 = uVar14;

+      }

+    }

+  }

+  else {

+    if (0xc < param_2) {

+      if (param_2 == 0xe) {

+        uVar4 = *(uint *)(p_Var7 + 0x98);

+        *param_3 = uVar4;

+        if ((*(uint *)(p_Var7 + 0x9c) & 0x40000) == 0) goto LAB_2;

+        uVar4 = uVar4 & 0xfffffffd;

+LAB_3:

+        *param_3 = uVar4;

+        uVar10 = 0;

+      }

+      else {

+        if (param_2 == 0x11) {

+          if (param_3 != (ulong *)0x0) {

+            param_3[2] = 0;

+            param_3[3] = 0;

+            if (*(longlong *)(p_Var7 + 0xa8) == 0) {

+              uVar10 = 0xc0000225;

+              goto LAB_2;

+            }

+            uVar14 = Feature_3629870394__private_IsEnabledDeviceUsageNoInline();

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

+              pvVar8 = (void *)(*_KspKernelFunctions)(*(undefined4 *)(p_Var7 + 0xb0));

+            }

+            else {

+              pvVar8 = (void *)KSecAllocateContextBuffer();

+            }

+            *(void **)(param_3 + 2) = pvVar8;

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

+              memmove(pvVar8,*(void **)(p_Var7 + 0xa8),(ulonglong)*(uint *)(p_Var7 + 0xb0));

+              *param_3 = *(ulong *)(p_Var7 + 0xb0);

+              goto LAB_2;

+            }

+LAB_4:

+            uVar10 = 0xc000009a;

+            goto LAB_2;

+          }

+        }

+        else {

+          if (param_2 == 0x15) {

+            if (*(longlong *)(p_Var7 + 0x40) == 0) {

+              uVar10 = 0x80090302;

+            }

+            else {

+              *(longlong *)param_3 = *(longlong *)(p_Var7 + 0x40);

+            }

+            goto LAB_2;

+          }

+          if (param_2 != 0x1b) {

+            if (param_2 != 0x25) {

+LAB_5:

+              uVar10 = 0xc00000bb;

+              goto LAB_6;

+            }

+            if (((*(uint *)(p_Var7 + 0x9c) & 4) == 0) && ((*(uint *)(p_Var7 + 0x98) & 0x400) != 0))

+            {

+              uVar10 = 0xc00000bb;

+              goto LAB_2;

+            }

+            uVar4 = *(uint *)(p_Var7 + 0x9c) >> 0x11 & 1;

+            goto LAB_3;

+          }

+          if (param_3 != (ulong *)0x0) {

+            if (*(longlong *)(p_Var7 + 0xd0) != 0) {

+              uVar5 = *(uint *)(p_Var7 + 0xd8) >> 1;

+              uVar4 = 0x7ffe;

+              if ((0x7ffe < uVar5) || (uVar4 = uVar5, *(uint *)(p_Var7 + 0xd8) >> 1 != 0)) {

+                uVar14 = Feature_3629870394__private_IsEnabledDeviceUsageNoInline();

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

+                  pvVar8 = (void *)(*_KspKernelFunctions)(uVar4 * 2 + 2);

+                }

+                else {

+                  pvVar8 = (void *)KSecAllocateContextBuffer();

+                }

+                *(void **)param_3 = pvVar8;

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

+                  memmove(pvVar8,*(void **)(p_Var7 + 0xd0),(ulonglong)uVar4 * 2);

+                  *(undefined2 *)((ulonglong)uVar4 * 2 + *(longlong *)param_3) = 0;

+                  goto LAB_2;

+                }

+                goto LAB_4;

+              }

+            }

+            uVar10 = 0x80090303;

+            goto LAB_2;

+          }

+        }

+        uVar10 = 0xc000000d;

+      }

+      goto LAB_2;

+    }

+    if (param_2 == 0xc) goto LAB_0;

+    if (param_2 == 0) {

+      uVar12 = *(ulong *)(p_Var7 + 0x70);

+      bVar3 = KerbShouldUseLegacySspi(uVar12);

+      if (bVar3) {

+        pgVar13 = (gss_OID_desc_struct *)&DAT_7;

+        if ((*(uint *)(p_Var7 + 0x9c) & 0x10) == 0) {

+          pgVar13 = (gss_OID_desc_struct *)&DAT_8;

+        }

+        *param_3 = KerbMaxTokenSize;

+        uVar4 = ~-(uint)((*(uint *)(p_Var7 + 0x98) & 0x600) != 0) & 0x40000000;

+        if ((*(uint *)(p_Var7 + 0x98) & 0x1001c) == 0) {

+          param_3[1] = 4;

+        }

+        else if (*(int *)(p_Var7 + 0x70) - 0x11U < 2) {

+          param_3[1] = 0x1c;

+        }

+        else {

+          uVar5 = g_token_size(pgVar13,0x16,param_3 + 1);

+          uVar10 = (ulonglong)uVar5;

+          if ((int)uVar5 < 0) goto LAB_6;

+        }

+        uVar5 = KerbGetChecksumAndEncryptionType

+                          (p_Var7,'\x01',0x80000001,(long *)&local_48,(long *)&local_res20);

+        uVar10 = (ulonglong)uVar5;

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

+          uVar14 = CDLocateCSystem((int)local_res20,local_40);

+          uVar10 = uVar14 & 0xffffffff;

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

+            if ((*(uint *)(p_Var7 + 0x98) & 0x210) == 0x200) {

+              param_3[2] = 0;

+            }

+            else if (*(int *)(p_Var7 + 0x70) - 0x11U < 2) {

+              param_3[2] = 1;

+              uVar6 = 0x4c;

+            }

+            else {

+              uVar5 = uVar4 + 0x1e;

+              local_res20 = CONCAT44(local_res20._4_4_,uVar5);

+              param_3[2] = *(ulong *)(local_40[0] + 4);

+              uVar5 = g_token_size(pgVar13,uVar5,(ulong *)&local_res20);

+              uVar10 = (ulonglong)uVar5;

+              if ((int)uVar5 < 0) goto LAB_6;

+              uVar6 = (int)local_res20 - uVar4;

+            }

+            param_3[3] = uVar6;

+          }

+        }

+      }

+      else {

+        local_res20 = 0;

+        p_Var16 = &local_48;

+        local_40[0] = 0;

+        local_48 = 0;

+        local_40[1] = 0;

+        uVar4 = KerberosCryptoPolicy::GetMessageSizes

+                          (uVar12,&local_res20,local_40,p_Var16,local_40 + 1,

+                           in_stack_ffffffffffffffb0);

+        uVar10 = (ulonglong)uVar4;

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

+          local_res20 = local_res20 & 0xffffffffffffff00;

+          uVar4 = KerberosCryptoPolicy::CipherHasAttribute

+                            (*(long *)(p_Var7 + 0x70),8,(bool *)&local_res20,

+                             (Kerb3961PolicyType)p_Var16);

+          uVar10 = (ulonglong)uVar4;

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

+            pgVar13 = (gss_OID_desc_struct *)&DAT_7;

+            puVar1 = param_3 + 1;

+            if ((*(uint *)(p_Var7 + 0x9c) & 0x10) == 0) {

+              pgVar13 = (gss_OID_desc_struct *)&DAT_8;

+            }

+            *param_3 = KerbMaxTokenSize;

+            cVar15 = local_res20._0_1_;

+            if ((*(uint *)(p_Var7 + 0x98) & 0x1001c) == 0) {

+              *puVar1 = 4;

+            }

+            else {

+              *puVar1 = (uint)local_40[0];

+              if (local_res20._0_1_ != false) {

+                uVar4 = g_token_size(pgVar13,(uint)local_40[0],puVar1);

+                uVar10 = (ulonglong)uVar4;

+                if ((int)uVar4 < 0) goto LAB_6;

+              }

+            }

+            if ((*(uint *)(p_Var7 + 0x98) & 0x210) == 0x200) {

+              param_3[2] = 0;

+              param_3[3] = 0;

+            }

+            else {

+              if (local_48 != 0) {

+                uVar17 = (ulong)local_48;

+              }

+              param_3[3] = (ulong)local_40[1];

+              param_3[2] = uVar17;

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

+                uVar4 = *param_3;

+                uVar5 = (ulong)local_40[1] + uVar4;

+                if (uVar5 < uVar4) {

+                  param_3[3] = 0xffffffff;

+                  uVar10 = 0xc0000095;

+                }

+                else {

+                  param_3[3] = uVar5;

+                  uVar4 = g_token_size(pgVar13,uVar4,param_3);

+                  uVar10 = (ulonglong)uVar4;

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

+                    param_3[3] = param_3[3] - *param_3;

+                  }

+                }

+              }

+            }

+          }

+        }

+      }

+    }

+    else if (param_2 == 1) {

+      uVar14 = Feature_3629870394__private_IsEnabledDeviceUsageNoInline();

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

+        pvVar8 = (void *)(*_KspKernelFunctions)(*(ushort *)(p_Var7 + 0x48) + 2);

+      }

+      else {

+        pvVar8 = (void *)KSecAllocateContextBuffer();

+      }

+      *(void **)param_3 = pvVar8;

+      if (pvVar8 == (void *)0x0) goto LAB_1;

+      memmove(pvVar8,*(void **)(p_Var7 + 0x50),(ulonglong)*(ushort *)(p_Var7 + 0x48));

+      *(undefined2 *)(*(longlong *)param_3 + (ulonglong)(*(ushort *)(p_Var7 + 0x48) >> 1) * 2) = 0;

+    }

+    else if (param_2 == 2) {

+      param_3[0] = 0;

+      param_3[1] = 0;

+      *(undefined8 *)(param_3 + 2) = *(undefined8 *)(p_Var7 + 0x28);

+    }

+    else if (param_2 == 9) {

+      uVar17 = *(ulong *)(p_Var7 + 0x78);

+      *param_3 = uVar17;

+      if (uVar17 == 0) {

+        uVar14 = Feature_3629870394__private_IsEnabledDeviceUsageNoInline();

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

+          puVar9 = (undefined1 *)(*_KspKernelFunctions)();

+        }

+        else {

+          puVar9 = (undefined1 *)KSecAllocateContextBuffer(1);

+        }

+        *(undefined1 **)(param_3 + 2) = puVar9;

+        if (puVar9 == (undefined1 *)0x0) goto LAB_1;

+        *puVar9 = 0;

+      }

+      else {

+        uVar14 = Feature_3629870394__private_IsEnabledDeviceUsageNoInline();

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

+          pvVar8 = (void *)(*_KspKernelFunctions)(*param_3);

+        }

+        else {

+          pvVar8 = (void *)KSecAllocateContextBuffer();

+        }

+        *(void **)(param_3 + 2) = pvVar8;

+        if (pvVar8 == (void *)0x0) goto LAB_1;

+        memmove(pvVar8,*(void **)(p_Var7 + 0x80),(ulonglong)*(uint *)(p_Var7 + 0x78));

+      }

+    }

+    else {

+      if (param_2 == 10) goto LAB_0;

+      if (param_2 != 0xb) goto LAB_5;

+      *param_3 = 0;

+    }

+  }

+LAB_6:

+  if (p_Var7 == (_KERB_KERNEL_CONTEXT *)0x0) {

+    return uVar10;

+  }

+LAB_2:

+  KerbDereferenceContext(p_Var7);

+  return uVar10;

+}

+
```
