linux内核(5.4.81)——KASAN

阅读量    91445 |

分享到: QQ空间 新浪微博 微信 QQ facebook twitter

 

KASAN 简述

  • KASAN是内核用于动态检测内存错误的工具, 简单来说, 数据区域可分为两种:可访问区域,不可访问区域(red_zone).KASAN存在影子内存(shadow memory), 他和正常内存的比例是1:8, 即1byte shadow memory可以代表8bytes 正常内存的可访问性.
  • 128TB(内核正常内存) : 16TB(影子内存) —- Documentation/x86/x86_64/mm.rst x86-64 内存布局显示如下:
 ffffec0000000000 |  -20    TB | fffffbffffffffff |   16 TB | KASAN shadow memory
  • 具体规则(+: byte可访问, -: byte不可访问)
    • 如果1byte shadow memory对应的8bytes 内存都可访问, 则*(shadow memory) == 0
      [0] -> [+, +, +, +, +, +, +, +]
      
    • 如果1byte shadow memory对应的8bytes 内存都不可访问, 则*(shadow memory)为负数
      [-1] -> [-, -, -, -, -, -, -, -]
      
    • 如果1byte shadow memory对应的8bytes 内存中有N bytes可访问, 则*(shadow memory) == N
      if N = 3
      [3] -> [+, +, +, -, -, -, -, -]
      
  • 实现原理
    • 代码插桩: 利用编译器特性进行代码插桩, 当程序对内存进行读取或写入(load/store)时插入kasan检测代码
    • kasan检测代码: asan_loadN(addr)/asan_storeN(addr) (后面会对源码做详细分析), 主要功能是检测addr所在位置的N bytes内存是否可用.

 

源码分析

kasan检测入口

  • 使用宏定义实现asan_load/asan_store, 关键函数为check_memory_region_inline
#define DEFINE_ASAN_LOAD_STORE(size)                    \
    void __asan_load##size(unsigned long addr)            \
    {                                \
        check_memory_region_inline(addr, size, false, _RET_IP_);\
    }                                \
    EXPORT_SYMBOL(__asan_load##size);                \
    __alias(__asan_load##size)                    \
    void __asan_load##size##_noabort(unsigned long);        \
    EXPORT_SYMBOL(__asan_load##size##_noabort);            \
    void __asan_store##size(unsigned long addr)            \
    {                                \
        check_memory_region_inline(addr, size, true, _RET_IP_);    \
    }                                \
    EXPORT_SYMBOL(__asan_store##size);                \
    __alias(__asan_store##size)                    \
    void __asan_store##size##_noabort(unsigned long);        \
    EXPORT_SYMBOL(__asan_store##size##_noabort)

check_memory_region_inline

  • 当size==0时, 对内存不做读写操作, 正常返回
  • addr必须大于KASAN_SHADOW_START对应的正常地址, 即addr必须在shadow映射的界限内
  • memory_is_poisoned作为核心函数判断内存是否可用
static __always_inline bool check_memory_region_inline(unsigned long addr,
                        size_t size, bool write,
                        unsigned long ret_ip)
{
    if (unlikely(size == 0))
        return true;

    if (unlikely((void *)addr <
        kasan_shadow_to_mem((void *)KASAN_SHADOW_START))) {
        kasan_report(addr, size, write, ret_ip);
        return false;
    }

    if (likely(!memory_is_poisoned(addr, size)))
        return true;

    kasan_report(addr, size, write, ret_ip);
    return false;
}

memory_is_poisoned

  • size 如果为常量, 则对1, 2-4-8, 16这三种情况分开讨论
  • size 不为常量进入memory_is_poisoned_n
static __always_inline bool memory_is_poisoned(unsigned long addr, size_t size)
{
    // 判断size是否为常量
    if (__builtin_constant_p(size)) {
        switch (size) {
        case 1:
            return memory_is_poisoned_1(addr);
        case 2:
        case 4:
        case 8:
            return memory_is_poisoned_2_4_8(addr, size);
        case 16:
            return memory_is_poisoned_16(addr);
        default:
            BUILD_BUG();
        }
    }

    return memory_is_poisoned_n(addr, size);
}

memory_is_poisoned_1

  • 通过kasan_mem_to_shadow获得addr对应的shadow_addr, ((s8 )shadow_addr)获得shadow_addr所对应的8bits内存值shadow_value
  • 因为1byte shadow对应8bytes, 所以可以将 8bytes对齐的addr -> 8bytes对齐的addr+8 设为一个内存组, 对应1byte shadow, 此处addr&7获得addr在该组中的偏移量last_accessible_byte
  • 比较偏移量与shadow_value(该组内可访问内存的byte 数), 如果last_accessible_byte <= shadow_value 显然addr可访问(当shadow_value==0时, 表示8bytes皆可访问)
static __always_inline bool memory_is_poisoned_1(unsigned long addr)
{
    s8 shadow_value = *(s8 *)kasan_mem_to_shadow((void *)addr);

    if (unlikely(shadow_value)) {
        s8 last_accessible_byte = addr & KASAN_SHADOW_MASK;
        return unlikely(last_accessible_byte >= shadow_value);
    }

    return false;
}

memory_is_poisoned_2_4_8

  • 与memory_is_poisoned_1的区别在于此处多考虑了一种情况(待store/read内存跨越两个内存组)
  • 对于跨越内存组的情况, 需要满足第一个内存组8bytes皆可访问(0), 第二个内存组shadow_value >= 组内偏移
  • 如果不跨越内存, 只判断末尾地址是否可store/load 1byte 内存
static __always_inline bool memory_is_poisoned_2_4_8(unsigned long addr,
                        unsigned long size)
{
    u8 *shadow_addr = (u8 *)kasan_mem_to_shadow((void *)addr);

    /*
     * Access crosses 8(shadow size)-byte boundary. Such access maps
     * into 2 shadow bytes, so we need to check them both.
     */
    if (unlikely(((addr + size - 1) & KASAN_SHADOW_MASK) < size - 1))
        return *shadow_addr || memory_is_poisoned_1(addr + size - 1);

    return memory_is_poisoned_1(addr + size - 1);
}

memory_is_poisoned_16

  • 只有addr本身为8bytes 对齐时才会只跨越两个内存组, 否则跨越三个内存组
  • 对于跨越三个内存组的情况, 需要满足前两个内存组内存皆可访问(16bit shadow_value == 0), 同时第三个内存组shadow_value >= 组内偏移
  • 如果只跨越两个内存组, 只需要16bit shadow_value == 0即可
static __always_inline bool memory_is_poisoned_16(unsigned long addr)
{
    u16 *shadow_addr = (u16 *)kasan_mem_to_shadow((void *)addr);

    /* Unaligned 16-bytes access maps into 3 shadow bytes. */
    if (unlikely(!IS_ALIGNED(addr, KASAN_SHADOW_SCALE_SIZE)))
        return *shadow_addr || memory_is_poisoned_1(addr + 15);

    return *shadow_addr;
}

memory_is_poisoned_n

  • memory_is_nonzero:
    • 首先定位与待访问内存块对应的shadow_mem_block, 检测shadow_mem_block中的shadow_value是否全为0, 如果全为0, 则内存块可访问, 从memory_is_poisoned_n返回
    • 如果shadow_value不全为0, 则找到第一个不为0的shadow_value对应的shadow_addr, return shadow_addr
  • 得到memory_is_nonzero中返回的shadow_addr, 如果shadow_addr == last_shadow(末尾地址对应的shadow_addr) 则内存块可访问, 从memory_is_poisoned_n返回
  • 否则判断末尾地址是否可store/load 1byte(比较末尾地址偏移与last_shadow的大小)
static __always_inline bool memory_is_poisoned_n(unsigned long addr,
                        size_t size)
{
    unsigned long ret;

    ret = memory_is_nonzero(kasan_mem_to_shadow((void *)addr),
            kasan_mem_to_shadow((void *)addr + size - 1) + 1);

    if (unlikely(ret)) {
        unsigned long last_byte = addr + size - 1;
        s8 *last_shadow = (s8 *)kasan_mem_to_shadow((void *)last_byte);

        if (unlikely(ret != (unsigned long)last_shadow ||
            ((long)(last_byte & KASAN_SHADOW_MASK) >= *last_shadow)))
            return true;
    }
    return false;
}

 

实例分析

buddy_kasan

kasan_alloc_pages: 标记shadow_mem为0, kasan_free_pages: 标记shadow_mem为不可访问

验证代码

  • 编写kasan驱动, 使用alloc_pages调用buddy分配内存, 查看分配后以及释放后的shadow_mem内存(local_addr[0] = ‘\x10’; 对buddy分配的内存块做store操作, 会触发__asan_store1代码插桩)
long kasan_ioctl(struct file* filp, unsigned int cmd, unsigned long arg)
{
    char *local_addr = NULL;
    struct page *local_pg = alloc_pages(GFP_KERNEL, 2);
    local_addr = page_address(local_pg);
    local_addr[0] = '\x10';
    __free_pages(local_pg, 2);

    printk(KERN_DEBUG "[+] modules kasan debug\n");

    return 0;
}
  • ida反汇编代码(存在_asan_store1_noabort(v5), 猜测成立)
__int64 __fastcall kasan_ioctl(file *filp, unsigned int cmd, unsigned __int64 arg)
{
  __int64 v3; // r13
  __int64 v4; // r12
  _BYTE *v5; // r12

  _fentry__(filp, cmd, arg);
  v3 = alloc_pages_current(3264LL, 2LL);
  _asan_load8_noabort(&vmemmap_base);
  v4 = v3 - vmemmap_base;
  _asan_load8_noabort(&page_offset_base);
  v5 = (_BYTE *)(page_offset_base + (v4 >> 6 << 12));
  _asan_store1_noabort(v5);
  *v5 = 0x10;
  printk(&unk_1C0, v5);
  _free_pages(v3, 2LL);
  printk(&unk_200, 2LL);
  return 0LL;
}

buddy_kasan 动态调试

  • 在call __asan_store1处下断点, 查看rdi内容
      gef➤  p $rdi
      $1 = 0xffff88805b034000
    
  • 计算shadow_mem = addr >> 3 + 0xdffffc0000000000, 所以0xffff88805b034000对应的shadow_mem: 0xffffed100b606800
      static inline void *kasan_mem_to_shadow(const void *addr)
      {
          return (void *)((unsigned long)addr >> KASAN_SHADOW_SCALE_SHIFT)
              + KASAN_SHADOW_OFFSET;
      }
    
  • 查看shadow_mem内容(shadow_value=0x0, 表示内存块可访问)
      gef➤  x/16xg 0xffffed100b606800
      0xffffed100b606800:     0x0000000000000000      0x0000000000000000
      0xffffed100b606810:     0x0000000000000000      0x0000000000000000
      0xffffed100b606820:     0x0000000000000000      0x0000000000000000
      0xffffed100b606830:     0x0000000000000000      0x0000000000000000
      0xffffed100b606840:     0x0000000000000000      0x0000000000000000
      0xffffed100b606850:     0x0000000000000000      0x0000000000000000
      0xffffed100b606860:     0x0000000000000000      0x0000000000000000
      0xffffed100b606870:     0x0000000000000000      0x0000000000000000
    
  • 程序执行__free_pages, 释放buddy内存块, 再次查看shadow_mem(0xff=-1, 内存块不可访问)
      gef➤  x/16xg 0xffffed100b606800
      0xffffed100b606800:     0xffffffffffffffff      0xffffffffffffffff
      0xffffed100b606810:     0xffffffffffffffff      0xffffffffffffffff
      0xffffed100b606820:     0xffffffffffffffff      0xffffffffffffffff
      0xffffed100b606830:     0xffffffffffffffff      0xffffffffffffffff
      0xffffed100b606840:     0xffffffffffffffff      0xffffffffffffffff
      0xffffed100b606850:     0xffffffffffffffff      0xffffffffffffffff
      0xffffed100b606860:     0xffffffffffffffff      0xffffffffffffffff
      0xffffed100b606870:     0xffffffffffffffff      0xffffffffffffffff
    
  • 计算shadow_mem边界(mem:shadow_mem=8:1), alloc_pages申请4页(0x1000 4)对应shadow_mem(0x1000 4/8=0x800), 发现0xff与0xfc的分界, 猜测成立
      gef➤  x/16xg 0xffffed100b606800+0x800-0x10
      0xffffed100b606ff0:     0xffffffffffffffff      0xffffffffffffffff
      0xffffed100b607000:     0xfcfcfcfcfcfcfcfc      0xfcfcfcfcfcfcfcfc
      0xffffed100b607010:     0xfcfcfcfcfcfcfcfc      0xfcfcfcfcfcfcfcfc
      0xffffed100b607020:     0xfcfcfcfcfcfcfcfc      0xfcfcfcfcfcfcfcfc
      0xffffed100b607030:     0xfcfcfcfcfcfcfcfc      0xfcfcfcfcfcfcfcfc
      0xffffed100b607040:     0xfcfcfcfcfcfcfcfc      0xfcfcfcfcfcfcfcfc
      0xffffed100b607050:     0xfcfcfcfcfcfcfcfc      0xfcfcfcfcfcfcfcfc
      0xffffed100b607060:     0xfcfcfcfcfcfcfcfc      0xfcfcfcfcfcfcfcfc
    
  • 由上述调试结果可知, buddy_kasan可有效的检测内存越界以及uaf

slub_kasan

提到slub_kasan不得不提及slub_debug, slub_debug是slub早期的内存检测机制, 想详细的了解可以看一下这篇文章 slub_debug原理, 或者我之前写的一篇文章点击此处

在这里我简单的描述一下slub_debug的原理:

  • 首先slub算法将page切割成一个一个的slub_obj, obj的布局大概是当obj空闲时, 复用头部空间用于存储free_list(指向下一个空闲obj)
  • 当slub_debug开启后, slub_obj的布局将发生非常大的改变如下, 第一行为初始布局, 第二行为开启slub_debug后的布局
  • slub_debug
  • 图中red_zone为右边界越界检测, red_left_pad为左边界越界检测, 这里对于red_left_pad着重说一下, 如果从第二幅图来看, 怎么也看不出左边界越界检测原理, 但是如果布局是第三幅图的话, 就非常明了了. 所以重点在于第二幅布局如何变成第三幅布局, slub的实现是, 每个obj在设计时仍然采用第二副布局, 但却在page开头开辟了一个red_left_pad, 这样就巧妙的完成了转换(至于为什么要经过这么一番转换, 只能说是历史遗留问题, 设计右边界越界检测时并没有考虑左边界越界)
  • 然后再说一下slub_debug的局限性, slub_debug虽然和kasan一样设计了red_zone但是, slub_debug的安全检测只在alloc/free时启动, 即如果一个越界内存块永远不被释放, 则安全漏洞很难被发现(为了解决这个问题, slub设计了slub_info可以主动的去触发安全检测, 但是和kasan相比, 在检测范围上仍然很局限 —- 只能检测slub内存问题, 同时还有一个非常重要的问题, slub_debug的red_zone是和填充数据位于同一内存块, 是可以被修改的, 有被劫持的风险)
  • 关于slub_debug就说这么多, 继续研究slub_kasan(slub_kasan的布局在slub_debug上面再加一个)

slub_debug

  • kasan_poison_slab: 当创建kmem_cache时将page对应的shadow_mem标记为KASAN_KMALLOC_REDZONE, 表示内存不可访问
      void kasan_poison_slab(struct page *page)
      {
          unsigned long i;
    
          for (i = 0; i < compound_nr(page); i++)
              page_kasan_tag_reset(page + i);
          kasan_poison_shadow(page_address(page), page_size(page),
                  KASAN_KMALLOC_REDZONE);
      }
    
  • kasan_kmalloc: 当使用kmalloc(x) 申请内存后, 有一部分内存可用, 填充red_zone, 修改shadow_mem(kasan_kmalloc和下面全局变量修改shadow_mem的原理类似, 可以滑到下面看看全局变量_kasan, 大致思路就是填充从obj_start+size到obj末尾内存为red_zone)

全局变量_kasan

asan_register_globals: 根据 struct kasan_global为全局变量填充shadow_mem, asan_unregister_globals实现为空

验证代码

  • 目标全局变量为global_var
      char global_var[34] = {'a', 'b', 'c', 'd'};
    
      long kasan_ioctl(struct file* filp, unsigned int cmd, unsigned long arg)
      {
          global_var[0] = 'x';
          global_var[34] = '*';
          return 0;
      }
    
  • ida反汇编代码
      __int64 __fastcall kasan_ioctl(file *filp, unsigned int cmd, unsigned __int64 arg)
      {
          __int64 result; // rax
    
          _fentry__(filp, cmd, arg);
          global_var[0] = 120;
          _asan_store1_noabort(&global_var[34]);
          result = 0LL;
          global_var[34] = 42;
          return result;
      }
    

全局变量 动态调试

  • 查看global_var内存(0xffffffffc000a000)与其对应的shadow_mem(0xfffffbfff8001400)发现, global_var存在34 bytes有效内存, 62 bytes为无效内存(red_zone)
      gef➤  disassemble
      Dump of assembler code for function kasan_ioctl:
      => 0xffffffffc0008000 <+0>:     data16 data16 data16 xchg ax,ax
      0xffffffffc0008005 <+5>:     push   rbp
      0xffffffffc0008006 <+6>:     mov    rdi,0xffffffffc000a022
      0xffffffffc000800d <+13>:    mov    BYTE PTR [rip+0x1fec],0x78        # 0xffffffffc000a000
      0xffffffffc0008014 <+20>:    mov    rbp,rsp
      0xffffffffc0008017 <+23>:    call   0xffffffff8145d790 <__asan_store1>
      0xffffffffc000801c <+28>:    xor    eax,eax
      0xffffffffc000801e <+30>:    mov    BYTE PTR [rip+0x1ffd],0x2a        # 0xffffffffc000a022
      0xffffffffc0008025 <+37>:    pop    rbp
      0xffffffffc0008026 <+38>:    ret
      End of assembler dump.
      gef➤  x/2xg 0xffffffffc000a000
      0xffffffffc000a000:     0x0000000064636261      0x0000000000000000
      gef➤  x/2xg 0xfffffbfff8001400
      0xfffffbfff8001400:     0xfafafa0200000000      0x00000000fafafafa
      gef➤
    
  • 进一步验证red_zone原理(ida显示驱动init_array段中存在指向__asan_register_globals的函数指针, 显然在驱动初始化阶段会调用该函数)
  • 分析__asan_register_globals源码发现一个用来修饰全局变量的结构体(存放于.data段), 结合ida反汇编结果后填充结构体如下:
      struct kasan_global {
          const void *beg=0xffffffffc000a000;        /* Address of the beginning of the global variable. */
          size_t size=0x22;            /* Size of the global variable. */
          size_t size_with_redzone=0x60;    /* Size of the variable + size of the red zone. 32 bytes aligned */
          const void *name="global_var";
          const void *module_name="/home/povcfe/code/modules/kasan/kasan.c";    /* Name of the module where the global variable is declared. */
          unsigned long has_dynamic_init=0;    /* This needed for C++ */
      #if KASAN_ABI_VERSION >= 4
          struct kasan_source_location *location;
      #endif
      #if KASAN_ABI_VERSION >= 5
          char *odr_indicator="/home/povcfe/code/modules/kasan/kasan.c";
      #endif
      };
    
  • size_with_redzone=0x60, 动调时发现redzone为62(0x3e) bytes, 显然此处size_with_redzone不可能被直接使用, 继续分析源码
  • __asan_register_globals->register_global(特别关注aligned_size, 这里会解决上诉问题)
      static void register_global(struct kasan_global *global)
      {
          size_t aligned_size = round_up(global->size, KASAN_SHADOW_SCALE_SIZE);
    
          // 设置有效内存对应的shadow_mem, 特别注意内存组内有效N byte不足8 bytes时, 需要设置shadow_value=N
          kasan_unpoison_shadow(global->beg, global->size);
    
          // 填充8 bytes对齐的redzone对应的shadow_mem为KASAN_GLOBAL_REDZONE
          kasan_poison_shadow(global->beg + aligned_size,
              global->size_with_redzone - aligned_size,
              KASAN_GLOBAL_REDZONE);
      }
    
  • 分析aligned_size原理(算数太差, 直接用c实现了一下, aligned_size=0x28)
      #define __round_mask(x, y) ((__typeof__(x))((y)-1))
      #define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
    
      #include <stdio.h>
    
      size_t __round_mask(size_t x, size_t y)
      {
          return ((__typeof__(x))((y)-1));
      }
    
      size_t round_up(size_t x, size_t y)
      {
          return ((((x)-1) | __round_mask(x, y))+1);
      }
    
      int main()
      {
          size_t res = round_up(0x22, 7);
          printf("0x%lx", res);
      }
    
  • 故 global->size_with_redzone(0x60) = 0x28(0x22(size) + 0x6(red_zone)) + 0x38(red_zone), 即有效内存空间0x22 bytes, red_zone(0x6 + 0x38) bytes

栈变量_kasan

__kasan_unpoison_stack: 设置栈内有效内存shadow_mem

验证代码

  • 目标栈变量 stack_var
      long kasan_ioctl(struct file* filp, unsigned int cmd, unsigned long arg)
      {
          char stack_var[0x4] = {'a', 'b', 'c', 'd'};
          stack_var[0x0] = 'x';
    
          printk(KERN_DEBUG "[+] %s\n", stack_var);
          return 0;
      }
    
  • ida反汇编代码(注意到0xF1(KASAN_STACK_LEFT), 0xF3(KASAN_STACK_RIGHT)字段, 猜测stack_kasan的shadow_mem填充代码是直接通过编译器插入源代码中的)
      __int64 __fastcall kasan_ioctl(file *filp, unsigned int cmd, unsigned __int64 arg)
      {
          _DWORD *v3; // rbx
          _QWORD v5[4]; // [rsp-70h] [rbp-70h] BYREF
          int v6; // [rsp-50h] [rbp-50h] BYREF
          unsigned __int64 v7; // [rsp-18h] [rbp-18h]
    
          _fentry__(filp, cmd, arg);
          v3 = (_DWORD *)(((unsigned __int64)v5 >> 3) - 0x2000040000000000LL);
          v5[0] = 1102416563LL;
          v5[1] = "1 32 4 12 stack_var:15";
          v5[2] = kasan_ioctl;
          *v3 = 0xF1F1F1F1;
          v3[1] = 0xF3F3F304;
          v7 = __readgsqword(0x28u);
          v6 = 0x64636278;
          printk(&unk_220, &v6);
          *(_QWORD *)v3 = 0LL;
          return 0LL;
      }
    

栈变量 动态调试

  • 根据ida反汇编代码猜测栈变量存在左右边界(red_zone)且关于32 bytes对齐
  • stack_var(0xffff88805b02fcf0)与其shadow_mem(0xffffed100b605f9e)内容如下, 可知栈变量有效内存为4 bytes, red_zone_size: (8 3 + 8 – 4) + 8 3 = 52(左边界red_zone为32bytes, 右边界red_zone+size关于32 bytes对齐, 总red_zone大小与全局变量相同)
      gef➤  x/8xg 0xffff88805b02fcf0-0x20
      0xffff88805b02fcd0:     0x0000000041b58ab3      0xffffffffc000903c
      0xffff88805b02fce0:     0xffffffffc00080e1      0xffff88805e404500
      0xffff88805b02fcf0:     0xffff888064636261      0x0000000200000101
      0xffff88805b02fd00:     0x000000000000004c      0x0000000000000000
      gef➤  x/4xg 0xffffed100b605f9e-0x10
      0xffffed100b605f8e:     0x0000000000000000      0xf1f1f1f100000000
      0xffffed100b605f9e:     0x00000000f3f3f304      0x0000000000000000
      gef➤
    
  • 待函数返回(栈变量销毁时), 会将shadow_mem置0(见ida伪代码)
      *(_QWORD *)v3 = 0LL;
    
  • 在kasan源码中没有找到填充red_zone的代码, 且栈变量左边界red_zone对应的内存处存放了栈变量信息, 函数信息. 所以猜测栈变量填充red_zone是在编译阶段实现的, 且左边界填充内容为用于描述栈的结构体
分享到: QQ空间 新浪微博 微信 QQ facebook twitter
|推荐阅读
|发表评论
|评论列表
加载更多