已了解MTE原理的读者可跳过此章节。

MTE利用ARMv8的TBI (Top-Byte Ignore) 特性，使用指针的高4 bits存储tag，在每个进程中有一段专用的内存用于存储tag。当为内存指定了某个tag后，程序必须带上正确的tag访问内存，若tag错误，程序抛出错误信号SIGSEGV，如下图所示：

指令集提供了系列指令来操作tag，此处举例说明MTE的基本用法：

; x0 is a pointerirg  x1, x0stg  x1, [x1]ldr  x0, [x1]

1. IRG (Insert Random Tag) 指令为指针x0生成一个随机tag，将结果保存至x1中。
2. STG (Store Allocation Tag) 指令将tag应用至内存中，生效的长度取决于颗粒度，一般为16字节。
3. LDR (Load Register) 使用带有tag的指针读取内存。

Chrome - PartitionAlloc

分配

1.  从ThreadCache中分配，不变动tag直接返回。
2.  从空闲的SlotSpan中分配，不变动tag直接返回。
3. 若以上两种情况均不满足，分配一个新的SlotSpan，对其中所有空闲的堆块打上随机的tag。

    if (PA_LIKELY(use_tagging)) {      // Ensure the MTE-tag of the memory pointed by other provisioned slot is      // unguessable. They will be returned to the app as is, and the MTE-tag      // will only change upon calling Free().      next_slot_ptr =          TagMemoryRangeRandomly(next_slot, TagSizeForSlot(root, slot_size));

释放

      void* retagged_slot_start = internal::TagMemoryRangeIncrement(          ObjectToTaggedSlotStart(object), tag_size);      // Incrementing the MTE-tag in the memory range invalidates the |object|'s      // tag, so it must be retagged.      object = TaggedSlotStartToObject(retagged_slot_start);

(过去的) 潜在威胁

1. 触发漏洞得到一个UAF的对象victim，但此时不触发UAF。
2. 连续分配并释放一个与victim大小相同的对象15次，此时攻击者控制的对象的tag与victim的tag相同。
3. 触发UAF。

1. 任意次数地分配任意大小的堆块。
2. 自由地释放自己分配的对象。

分析

Glibc - Ptmalloc

分配

      victim = tcache_get (tc_idx);      return tag_new_usable (victim);  // ...  victim = _int_malloc (ar_ptr, bytes);  // ...  victim = tag_new_usable (victim);

      /* Mark the chunk as belonging to the library again.  */      (void)tag_region (chunk2mem (p), memsize (p));
      ar_ptr = arena_for_chunk (p);      _int_free (ar_ptr, p, 0);

对于这样的分配策略，大有一种“一力降十会”的感觉。在性能和安全的权衡之间Glibc选择了安全：无论是任何的分配大小、任何分配的来源 (tcache、fastbin、smallbin...)，都会被重新打上随机的tag。

1. 每两个chunk (tag非0) 之间一定存在着chunk头或free chunk (tag 0) 作为隔阂，扮演了类似Guard Page的存在，可以有效缓解线性溢出。
2. free后的chunk (tag 0) 和正在使用的chunk (tag非0) 拥有的tag一定不一样，可以有效缓解UAF。

Android - Scudo

分配

1. Scudo只会给Primary类型 (大小 < 0x10000) 的堆块打上tag，对于更大的Secondary类型，其通过内存映射的方式分配空间，目前暂不支持给这类空间分配tag。
2. Scudo在重用被释放的堆块时，会直接保存并使用其在释放时打上的UAF tag；否则将分配一个随机tag。

释放

      if (Header->ClassId) {        if (!TSDRegistry.getDisableMemInit()) {          uptr TaggedBegin, TaggedEnd;          const uptr OddEvenMask = computeOddEvenMaskForPointerMaybe(              Options, reinterpret_cast<uptr>(getBlockBegin(Ptr, Header)),              Header->ClassId);          // Exclude the previous tag so that immediate use after free is          // detected 100% of the time.          setRandomTag(Ptr, Size, OddEvenMask | (1UL << PrevTag), &TaggedBegin,                       &TaggedEnd);        }      }

  uptr computeOddEvenMaskForPointerMaybe(const Options &Options, uptr Ptr,                                         uptr ClassId) {    if (!Options.get(OptionBit::UseOddEvenTags))      return 0;

    // If a chunk's tag is odd, we want the tags of the surrounding blocks to be    // even, and vice versa. Blocks are laid out Size bytes apart, and adding    // Size to Ptr will flip the least significant set bit of Size in Ptr, so    // that bit will have the pattern 010101... for consecutive blocks, which we    // can use to determine which tag mask to use.    return 0x5555U << ((Ptr >> SizeClassMap::getSizeLSBByClassId(ClassId)) & 1);  }

这种配置涉及到UAF检测和缓冲区溢出检测之间的权衡。启用UseOddEvenTags时，相邻堆块的tag奇偶性不同，这断绝了随机分配的tag恰好相同的可能性，从而提高了检测缓冲区溢出的可能性。然而，另一方面，这种情况下每次随机分配的tag的奇偶性是固定的，这导致其标记空间减半，使得UAF更加难以被检测出来。

声明：此表格仅对比了各个堆分配器中MTE的实现，并不能代表堆分配器整体的安全性。

• 带tag的最大堆块大小

  Ptmalloc会给任意大小的堆块都打上tag；而出于性能考虑，Scudo和PartitionAlloc分别只能保护小于0x10000和0x400的堆块。
• 内存破坏防御能力
• Linear Overflow

  Ptmalloc和Scudo的chunk头都使用了0作为tag，因此两个堆块之间一定存在着一块red zone，可以有效缓解线性溢出；而PartitionAlloc的metadata不在堆块头部，因此有一定概率相邻堆块的tag恰好相同。
• Non-linear OOB

  对于非线性的越界访问，Scudo的tag奇偶性可以保证相邻的堆块的tag必定不同，从而可以增加堆块周围的red zone的大小，使小范围的OOB更有可能被检测到。
• UAF

  PartitionAlloc中对于UAF漏洞的潜在风险在上述章节已详细说明，此处需额外注明的是，PartitionAlloc并不（仅）依赖MTE来防御UAF漏洞，其借助MiraclePtr [9]本身已具备了极为强大的UAF防御能力；Scudo在开启tag奇偶性的情况下，tag的分配空间会减半，使得tag碰撞的概率上升。
• Uninitialized Memory

  MTE并不能很好地改善内存未初始化的问题，诸如PartitionAlloc和Ptmalloc都不会对内存进行初始化操作。
• tag管理策略

  堆块的分配和释放作为一个整体在此项评估。PartitionAlloc在重用缓存中的堆块时，并不会重新生成新的tag，而是继续沿用旧的tag，而释放时仅将tag加一；而另外两个堆分配器都完成了对tag的重新生成。

• 对于metadata的保护

  Ptmalloc和Scudo都没有使用tag来保护chunk头等metadata，其默认的tag为0，使其可以作为相邻堆块之间的隔离区域，但同时也可能存在着被恶意破坏的风险；值得一提的是，PartitionAlloc的metadata不会保存在堆块的头部，因此不容易被破坏。
• 释放一个带有错误tag的地址

  在释放堆块时，PartitionAlloc和Scudo并不会检查tag的正确性，而是直接进行untag操作，因此可以成功释放一个带有错误tag的地址，但是这样的缺陷导致的攻击场景有限，需要结合其他的攻击手段一起利用，因此我们没有将其定为较高的风险程度；而Ptmalloc会检查tag是否正确，如果检查不符则产生异常。

    /* Quickly check that the freed pointer matches the tag for the memory.       This gives a useful double-free detection.  */    if (__glibc_unlikely (mtag_enabled))      *(volatile char *)mem;

• 内存未初始化的防御仍依赖于软件实现。
• 栈上的变量是否会得到MTE的加固，是否会因为性能原因难以落地。
• 对mmap出的内存打上tag缺乏kernel层的支持。
• 对于大块内存buffer，如ring buffer、共享内存等，很难得到MTE的有效保护。
• 程序的data段数据不受MTE的保护。

攻防演进至此，攻击者从多年前一个栈溢出即可攻破系统，至如今需要环环相扣的漏洞来突破系统防御的层层壁垒，攻守形势逆转。但我们也看到，即使像MTE这样先进的技术也存在盲点，内存安全仍道阻且长，我们期待未来更为精彩的发展。