2026-11-15 18:21:40 +00:00
2023-01-14 21:35:28 +01:00
2026-11-15 18:21:40 +00:00
2023-01-14 21:35:28 +01:00

VmdtStr

Detect VMMs with faulty handling of STR exit
NOTE: This detection requires the VMM in question to exit on descriptor table access, otherwise it won't work!

Showcase

This is the output on a KVM with no nested VMM active:

And this is with HVPP as a nested VMM:

How it works

This demo works because some public VMMs don't emulate STR instruction correctly. Let me quote the relevant part in the instruction set reference from Intel website:

When the destination operand is a 32-bit register, the 16-bit segment selector is copied into the lower 16 bits of the
register and the upper 16 bits of the register are cleared. When the destination operand is a memory location, the
segment selector is written to memory as a 16-bit quantity, regardless of operand size.

In 64-bit mode, operation is the *same*. The size of the memory operand is fixed at 16 bits. In register stores, the 2-
byte TR is *zero extended* if stored to a 64-bit register.

This is what the exit handler of HVPP is doing on an exit with reason descriptor table access.

oid vmexit_passthrough_handler::handle_ldtr_tr_access(vcpu_t& vp) noexcept
{
  auto instruction_info = vp.exit_instruction_info().ldtr_tr_access;

  cr3_guard _{ vp.guest_cr3() };

  auto& low_word =
    instruction_info.access_type == vmx::instruction_info_t::access_memory
      ? *reinterpret_cast<uint16_t*>(vp.exit_instruction_info_guest_va())
      // instruction_info.access_type == vmx::instruction_info::access_register
      :  reinterpret_cast<uint16_t&>(vp.context().gp_register[instruction_info.register_1]); // notice how it only cares about the lower bits, i.e u16

  switch (instruction_info.instruction)
  {
    case vmx::instruction_info_ldtr_tr_access_t::instruction_sldt:
      low_word = vp.guest_segment_selector(context_t::seg_ldtr).flags;
      break;

    case vmx::instruction_info_ldtr_tr_access_t::instruction_str:
      low_word = vp.guest_segment_selector(context_t::seg_tr).flags; // no zero extension is happening here, it only writes the lower bits and doesn't differentiate between the destination.
      break;

    case vmx::instruction_info_ldtr_tr_access_t::instruction_lldt:
      vp.guest_segment_selector(context_t::seg_ldtr, segment_selector_t{ low_word });
      break;

    case vmx::instruction_info_ldtr_tr_access_t::instruction_ltr:
      {
        //
        // After the segment selector is loaded in the task register,
        // the processor uses the segment selector to locate the segment
        // descriptor for the TSS in the global descriptor table(GDT).
        // It then loads the segment limit and base address for the TSS
        // from the segment descriptor into the task register.  The task
        // pointed to by the task register is marked busy, but a switch
        // to the task does not occur.
        // (ref: Vol2A[(LTR-Load Task Register)])
        //
        // TL;DR:
        //   LTR instruction sets busy bit in the TSS and we need to
        //   emulate this behavior.
        //
        auto selector = segment_selector_t{ low_word };
        vp.guest_segment_selector(context_t::seg_tr, selector);

        auto& descriptor = vp.guest_gdtr()[selector];
        descriptor.access.type |= segment_access_t::type_tss_busy_flag;
      }
      break;
  }
}

Disclaimer

This has been tested using HVPP and some other public VMMs, in a KVM virtual machine.
Although i think the results on bare metal should be the same, more evaluation is required if this should be used legitimately.

S
Description
A demonstration of how to detect HVPP users with descriptor table exiting enabled in VMCS controls.
Readme 51 KiB
Languages
C 61.1%
Assembly 38.9%