// 在可疑路径哈希表中，我在每个哈希行中保存一个单链表
typedef struct DUBIOUS_PATH_ {
     UNICODE_STRING path;
     struct DUBIOUS_PATH_* next;
} DUBIOUS_PATH;

typedef struct _UNICODE_STRING {
    USHORT Length;
    USHORT MaximumLength;
    PWCH   Buffer;
} UNICODE_STRING;

// 路径哈希表的最大值
#define HASH_MAX 0xffff
// 出于代码简单起见，我仅仅将路径上所有字符求和来计算一个0-0xffff范围内的
// 散列值
USHORT DubiousPathHash(PUNICODE_STRING mod_path)
{
     ULONG wchar_sum = 0;
     int i;
     ULONG wchar_cur;
     for (i = 0; i < mod_path->Length / sizeof(WCHAR); ++i)
     {
         wchar_cur = mod_path->Buffer[i];
         wchar_sum += wchar_cur;
     }
    return (USHORT)(wchar_sum & HASH_MAX);
}

// 哈希表，保存所有可疑路径。注意如果这里HASH_MAX
// 忘记加1，会导致一个典型的内核越界漏洞，可能导致崩溃并可能被外界利用
static DUBIOUS_PATH* g_dubious_path[HASH_MAX + 1] = { NULL };  （1）
// 操作哈希表用的锁。
static KSPIN_LOCK g_dubious_lock; （2）

BOOLEAN IsDubious(PUNICODE_STRING mod_path)
{
     KIRQL irql = PASSIVE_LEVEL;
     BOOLEAN locked = FALSE;
     BOOLEAN ret = FALSE;
     USHORT hash;
     do {
         // 在安全的中断级调用
         ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
         BreakIf(KeGetCurrentIrql() > APC_LEVEL); (1)
         // 检查参数并计算哈希值，然后加锁
         BreakIf(mod_path == NULL);
         // 注意如果路径过长，直接判断可疑，禁止任何超长路径的可执行模块加载。
         BreakDoIf(mod_path->Length >= DUBIOUS_MAX_PATH, ret = TRUE);  (2)
        hash = DubiousPathHash(mod_path);  (3)
          KeAcquireSpinLock(&g_dubious_lock, &irql); (5)
         locked = TRUE;
         // 对比所有的节点来寻找
      BreakDoIf(DubiousSearchInHashLine(g_dubious_path[hash], mod_path),
              ret = TRUE); (6)
     } while (0);
     DoIf(locked, KeReleaseSpinLock(&g_dubious_lock, irql));
     if (ret)
     {
         LOG(("KRPS: IsDubious: %wZ is dubious.\r\n", mod_path));  (7)
     }
     else
     {
         // 正常情况下，我们对不可疑的模块不显示,但需要时也可以显示一下
         // LOG(("KRPS: IsDubious: %wZ is not dubious.", mod_path));
     }
     return ret;
}

static BOOLEAN DubiousSearchInHashLine(
     DUBIOUS_PATH* hash_line, PUNICODE_STRING mod_path)
{
     BOOLEAN ret = FALSE;
     DUBIOUS_PATH* next = NULL;
     next = hash_line;
     while (next)
     {
         DUBIOUS_PATH_ASSERT(next);
         // 这里用大小写敏感比较。这是因为我之前已经做过了大写化。大
         // 小写敏感的不会浪费性能（虽然这浪费很小很小）
         if (RtlCompareUnicodeString(
              &next->path,
              mod_path,
              TRUE) == 0)
         {
              ret = TRUE;
              break;
         }
         next = next->next;
     }
     return ret;
}

void DubiousAppend(DUBIOUS_PATH* mod_path)
{
     DUBIOUS_PATH* hash_header = NULL;
     USHORT hash;
     KIRQL irql = PASSIVE_LEVEL;
     BOOLEAN locked = FALSE;
     DUBIOUS_PATH* next = NULL;
     DUBIOUS_PATH* to_release = NULL;
     do {
         // 此函数永远在安全的中断级调用
         ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
         BreakIf(KeGetCurrentIrql() > APC_LEVEL);
         // 检查参数并计算哈希值，然后加锁
         BreakIf(mod_path == NULL);
         hash = DubiousPathHash(&mod_path->path);
          KeAcquireSpinLock(&g_dubious_lock, &irql);  （1）          
         locked = TRUE;
         // 在插入之前，先要遍历所有节点。对比是否存在重复的节点。如果有，
         // 那就直接释放掉即可
         next = g_dubious_path[hash];
         // 有效性检查，提前发现乱指针bug
         DUBIOUS_PATH_ASSERT(next);
       BreakDoIf(DubiousSearchInHashLine(next, &mod_path->path),
              to_release = mod_path);  （2）
         // 到这里可以真正添加了
         hash_header = g_dubious_path[hash];
         g_dubious_path[hash] = mod_path;  （3）
         mod_path->next = hash_header;
         LOG(("KRPS: DubiousAppend: %wZ is dubious.\r\n", &mod_path->path));
     } while (0);
     DoIf(locked, KeReleaseSpinLock(&g_dubious_lock, irql)); （4）
     DoIf(to_release != NULL, ExFreePool(to_release));   （5）
     return;
}

static DUBIOUS_PATH* DubiousRemoveFromHashLine(
     DUBIOUS_PATH** hash_line, PUNICODE_STRING mod_path)
{
     DUBIOUS_PATH* ret = NULL;
     DUBIOUS_PATH* previous = NULL;
     DUBIOUS_PATH* next = NULL;
     previous = *hash_line;
     next = *hash_line;
     while (next)
     {
         DUBIOUS_PATH_ASSERT(next);
         // 这里用大小写敏感比较。这是因为我之前已经做过了大写化。大
         // 小写敏感比较性能较好
         if (RtlCompareUnicodeString(
              &next->path,
              mod_path,
              TRUE) == 0)
         {
              // 如果找到了，这里要进行脱链。
              ASSERT(previous != NULL);
              // 如果找到的是第一个，又要移除，那么就必须修改哈希链上的
              // 第一个为NULL
              if (previous == next)
              {
                   *hash_line = NULL;
              }
              else
              {
                   previous->next = next->next;
              }
              ret = next;
              break;
         }
         previous = next;
         next = next->next;
     }
     return ret;
}

// 清理并释放一个可疑路径
void DubiousRemove(PUNICODE_STRING path)
{
     DUBIOUS_PATH* hash_header = NULL;
     USHORT hash;
     KIRQL irql = PASSIVE_LEVEL;
     BOOLEAN locked = FALSE;
     DUBIOUS_PATH* to_release = NULL;
     DUBIOUS_PATH* next = NULL;
     do {
         // 只能在安全的中断级调用
         ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
         BreakIf(KeGetCurrentIrql() > APC_LEVEL);   (1)
         // 检查参数并计算哈希值，然后加锁
         BreakIf(path == NULL);
         hash = DubiousPathHash(path);
          KeAcquireSpinLock(&g_dubious_lock, &irql); (2)
         locked = TRUE;
         // 把src找到并删除了
         to_release = DubiousRemoveFromHashLine(
              &g_dubious_path[hash],
              path);
     } while (0);
     DoIf(locked, KeReleaseSpinLock(&g_dubious_lock, irql)); (3)
     if (to_release != NULL)
     {
         ExFreePool(to_release); (4)
         LOG(("KRPS: DubiousRemove: %wZ removed.\r\n", path));
     }
}

// 移动一个可疑路径。注意dst_path是个分配出来的DUBIOUS_PATH，本函数会负责
// 释放或者不释放（不释放就会插入哈希表中）。所以外部不需要再释放。
void DubiousMove(PUNICODE_STRING src_path, DUBIOUS_PATH* dst_path)
{
     DUBIOUS_PATH* hash_header = NULL;
     USHORT src_hash;
     KIRQL irql = PASSIVE_LEVEL;
     BOOLEAN locked = FALSE;
     DUBIOUS_PATH* to_release1 = NULL;
     DUBIOUS_PATH* to_release2 = NULL;
     DUBIOUS_PATH* next = NULL;
     USHORT dst_hash;
     do {
         // 在安全的中断级调用。
         ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
         BreakIf(KeGetCurrentIrql() > APC_LEVEL);
         // 检查参数并计算哈希值，然后加锁。
         BreakIf(src_path == NULL || dst_path == NULL);
         DUBIOUS_PATH_ASSERT(dst_path);
         LOG(("KRPS: DubiousMove: %wZ mov to\r\n", src_path));
         LOG(("KRPS: DubiousMove: %wZ\r\n", &dst_path->path));
         src_hash = DubiousPathHash(src_path);
          KeAcquireSpinLock(&g_dubious_lock, &irql);
         locked = TRUE;
         // 先把src找到并删除了
         to_release1 = DubiousRemoveFromHashLine(　    (1)
              &g_dubious_path[src_hash],
              src_path);
         // 然后把dst_path给追加进去。
         dst_hash = DubiousPathHash(&dst_path->path);  (2)
         next = g_dubious_path[dst_hash];
         DUBIOUS_PATH_ASSERT(next);
         // 如果dst已经存在，那么就释放dst_path，因为没有必要重复添加
       BreakDoIf(DubiousSearchInHashLine(next, &dst_path->path),
              to_release2 = dst_path);
         // 到这里可以真正添加了。
         hash_header = g_dubious_path[dst_hash];
         g_dubious_path[dst_hash] = dst_path;
         dst_path->next = hash_header;
     } while (0);
     DoIf(locked, KeReleaseSpinLock(&g_dubious_lock, irql));
     DoIf(to_release1, ExFreePool(to_release1));
     DoIf(to_release2, ExFreePool(to_release2));
}

# 往期推荐

1、Windows主机入侵检测与防御内核技术深入解析

2、BFS Ekoparty 2022 Linux Kernel Exploitation Challenge

3、银狐样本分析

4、使用pysqlcipher3操作Windows微信数据库

5、XYCTF两道Unity IL2CPP题的出题思路与题解