这个漏洞略叼，打了KPTI补丁之后内核访问用户态内存都要切CR3了，TLB全清，真是修复了现存INTEL-CPU过于流畅的问题。
PS：牙膏厂补上洞再坑一波钱美滋滋。

这不是真的，我不要换cpu

这是要把牙膏往回吸的节奏啊。

奇葩了，我的电脑我做主，ring3  层应用识别受到保护的内核空间布局又怎么地。呵呵，你微软个人操作系统也紧张个卯毛?

win7  不会修复这个漏洞...

关注中。。。

话说inter出的检测工具哪里可以下载到

//  SpecuCheck.cpp  :  Defines  the  entry  point  for  the  console  application.
//
/*Module  Name:

specucheck.c

Abstract:

This  module  implements  a  checker  app  for  CVE-2017-5754  and  CVE-2017-5715

Author:

Alex  Ionescu  (@aionescu)  03-Jan-2018  -  Initial  version

Environment:

User  mode  only.

--*/

//
//  OS  Headers
//
#include  <windows.h>
#include  <winternl.h>
#include  <stdio.h>

int  Spectre_main(int  argc,  char*  argv[]);


#define  NT_SUCCESS(Status)  ((NTSTATUS)(Status)  >=  0)

typedef  NTSTATUS  (__stdcall  *ZWQUERYSYSTEMINFORMATION)  (
       __in  SYSTEM_INFORMATION_CLASS  SystemInformationClass,
       __out_bcount_opt(SystemInformationLength)  PVOID  SystemInformation,
       __in  ULONG  SystemInformationLength,
       __out_opt  PULONG  ReturnLength
       );
//
//  Internal  structures  and  information  classes
//
#define  SystemSpeculationControlInformation  (SYSTEM_INFORMATION_CLASS)201
typedef  struct  _SYSTEM_SPECULATION_CONTROL_INFORMATION
{
       struct
       {
               ULONG  BpbEnabled  :  1;
               ULONG  BpbDisabledSystemPolicy  :  1;
               ULONG  BpbDisabledNoHardwareSupport  :  1;
               ULONG  SpecCtrlEnumerated  :  1;
               ULONG  SpecCmdEnumerated  :  1;
               ULONG  IbrsPresent  :  1;
               ULONG  StibpPresent  :  1;
               ULONG  SmepPresent  :  1;
               ULONG  Reserved  :  24;
       }  SpeculationControlFlags;
}  SYSTEM_SPECULATION_CONTROL_INFORMATION,  *PSYSTEM_SPECULATION_CONTROL_INFORMATION;

#define  SystemKernelVaShadowInformation          (SYSTEM_INFORMATION_CLASS)196
typedef  struct  _SYSTEM_KERNEL_VA_SHADOW_INFORMATION
{
       struct
       {
               ULONG  KvaShadowEnabled  :  1;
               ULONG  KvaShadowUserGlobal  :  1;
               ULONG  KvaShadowPcid  :  1;
               ULONG  KvaShadowInvpcid  :  1;
               ULONG  Reserved  :  28;
       }  KvaShadowFlags;
}  SYSTEM_KERNEL_VA_SHADOW_INFORMATION,  *PSYSTEM_KERNEL_VA_SHADOW_INFORMATION;

//
//  Welcome  Banner
//
const  WCHAR  WelcomeString[]  =  L"SpecuCheck  v1.0.0  --  Copyright  (c)  2018  Alex  Ionescu\n"
L"http://www.alex-ionescu.com  -  @aionescu\n"
L"----------------------------------------------------\n\n";

//
//  Error  String
//
const  WCHAR  UnpatchedString[]  =  L"Your  system  either  does  not  have  the  appropriate  patch,  "
L"or  it  may  not  support  the  information  class  required.\n";

//
//  Error  codes  used  for  clarity
//
typedef  enum  _SPC_ERROR_CODES
{
       SpcSuccess  =  0,
       SpcFailedToOpenStandardOut  =  -2,
       SpcFailedToQueryKvaShadowing  =  -3,
       SpcFailedToQuerySpeculationControl  =  -4,
}  SPC_ERROR_CODES;

INT
SpcMain  (
                 VOID
                 )
{
       HANDLE  hStdOut;
       NTSTATUS  status;
       //BOOL  boolResult;
       SYSTEM_KERNEL_VA_SHADOW_INFORMATION  kvaInfo;
       SYSTEM_SPECULATION_CONTROL_INFORMATION  specInfo;
       SPC_ERROR_CODES  errorCode;
       WCHAR  stateBuffer[512];
       INT  charsWritten;
       ZWQUERYSYSTEMINFORMATION    NtQuerySystemInformation  =  NULL;
       HMODULE  hntdll  =  GetModuleHandle(L"ntdll.dll");

       if  (!hntdll)
       {
               return  SpcSuccess;
       }
        NtQuerySystemInformation    =  (ZWQUERYSYSTEMINFORMATION)GetProcAddress(hntdll,  "NtQuerySystemInformation");
       if  (!NtQuerySystemInformation)
       {
               return  SpcSuccess;
       }
       //
       //  Open  the  output  handle  --  also  not  much  we  can  do  if  this  fails
       //
       hStdOut  =  CreateFile(L"CONOUT$",
               GENERIC_WRITE,
               0,
               NULL,
               OPEN_EXISTING,
               0,
               NULL);
       if  (hStdOut  ==  INVALID_HANDLE_VALUE)
       {
               hStdOut  =  INVALID_HANDLE_VALUE;
               errorCode  =  SpcFailedToOpenStandardOut;
               goto  Exit;
       }

       //
       //  We  now  have  display  capabilities  --  say  hello!
       //
       WriteConsole(hStdOut,  WelcomeString,  ARRAYSIZE(WelcomeString)  -  1,  NULL,  NULL);

       //
       //  Get  the  KVA  Shadow  Information
       //
       status  =  NtQuerySystemInformation(SystemKernelVaShadowInformation,
               &kvaInfo,
               sizeof(kvaInfo),
               NULL);
       if  (!NT_SUCCESS(status))
       {
               //
               //  Print  out  an  error  if  this  failed
               //
               WriteConsole(hStdOut,
                       UnpatchedString,
                       ARRAYSIZE(UnpatchedString)  -  1,
                       NULL,
                       NULL);
               errorCode  =  SpcFailedToQueryKvaShadowing;
               goto  Exit;
       }

       //
       //  Get  the  Speculation  Control  Information
       //
       status  =  NtQuerySystemInformation(SystemSpeculationControlInformation,
               &specInfo,
               sizeof(specInfo),
               NULL);
       if  (!NT_SUCCESS(status))
       {
               //
               //  Print  out  an  error  if  this  failed
               //
               WriteConsole(hStdOut,
                       UnpatchedString,
                       ARRAYSIZE(UnpatchedString)  -  1,
                       NULL,
                       NULL);
               errorCode  =  SpcFailedToQuerySpeculationControl;
               goto  Exit;
       }

       //
       //  Print  status  of  KVA  Features
       //
       charsWritten  =  swprintf_s(stateBuffer,
               ARRAYSIZE(stateBuffer),
               L"KVA  Shadowing  Enabled:  %s\n"
               L"KVA  Shadowing  with  User  Pages  Marked  Global:  %s\n"
               L"KVA  Shadowing  with  PCID  Support:  %s\n"
               L"KVA  Shadowing  with  INVPCID  Support:  %s\n\n",
               kvaInfo.KvaShadowFlags.KvaShadowEnabled  ?  L"yes"  :  L"no",
               kvaInfo.KvaShadowFlags.KvaShadowUserGlobal  ?  L"yes"  :  L"no",
               kvaInfo.KvaShadowFlags.KvaShadowPcid  ?  L"yes"  :  L"no",
               kvaInfo.KvaShadowFlags.KvaShadowInvpcid  ?  L"yes"  :  L"no");
       WriteConsole(hStdOut,  stateBuffer,  charsWritten,  NULL,  NULL);

       //
       //  Print  status  of  Speculation  Control  Features
       //
       charsWritten  =  swprintf_s(stateBuffer,
               ARRAYSIZE(stateBuffer),
               L"BPB  Enabled:  %s\n"
               L"BPB  Disabled  due  to  System  Policy:  %s\n"
               L"BPB  Disabled  due  to  No  Hardware  Support:  %s\n"
               L"Speculation  Controls  Enumerated:  %s\n"
               L"Speculation  Commands  Enumerated:  %s\n"
               L"IBRS  Speculation  Control  Present:  %s\n"
               L"STIBP  Speculation  Control  Present:  %s\n"
               L"Supervisor  Mode  Execution  Prevention  Present:  %s\n",
               specInfo.SpeculationControlFlags.BpbEnabled  ?  L"yes"  :  L"no",
               specInfo.SpeculationControlFlags.BpbDisabledSystemPolicy  ?  L"yes"  :  L"no",
               specInfo.SpeculationControlFlags.BpbDisabledNoHardwareSupport  ?  L"yes"  :  L"no",
               specInfo.SpeculationControlFlags.SpecCtrlEnumerated  ?  L"yes"  :  L"no",
               specInfo.SpeculationControlFlags.SpecCmdEnumerated  ?  L"yes"  :  L"no",
               specInfo.SpeculationControlFlags.IbrsPresent  ?  L"yes"  :  L"no",
               specInfo.SpeculationControlFlags.StibpPresent  ?  L"yes"  :  L"no",
               specInfo.SpeculationControlFlags.SmepPresent  ?  L"yes"  :  L"no");
       WriteConsole(hStdOut,  stateBuffer,  charsWritten,  NULL,  NULL);

       //
       //  This  is  our  happy  path 
       //
       errorCode  =  SpcSuccess;

Exit:
       //
       //  Close  output  handle  if  needed
       //
       if  (hStdOut  !=  INVALID_HANDLE_VALUE)
       {
               CloseHandle(hStdOut);
       }

       //
       //  Return  the  error  code  back  to  the  caller,  for  debugging
       //
       return  errorCode;
}


int  main(int  argc,  CHAR*  argv[])
{
       SpcMain();
       return  0;
}
看了下，采用的应该是类似LINUX下的KAISER技术，采用shadow  页表技术，R3,R0用不同的页表，内核地址在R3中只有极少数被映射，大部分都无效，R0中的都有效，并且R3地址也都能访问，只通过SMAP和SMEP来进行保护。

膜拜

在打了新的WIN10  补丁后，我们在  KPROCESS  里会看到

0:  kd>  dt  nt!_EPROCESS  @$proc  ImageFileName  Pcb.DirectoryTableBase  Pcb.UserDirectoryTableBase
***  ERROR:  Module  load  completed  but  symbols  could  not  be  loaded  for  LiveKdD.SYS
      +0x000  Pcb                                                :
            +0x028  DirectoryTableBase                  :  0x1ab002
            +0x278  UserDirectoryTableBase          :  0x2f00001
      +0x450  ImageFileName                            :  [15]    "System"
新的UserDirectoryTableBase  用来保存R3  的CR3  ,而原来的DirectoryTableBase则为R0的CR3


0:  kd>  ?  nt!KiSystemCall64Shadow
Evaluate  expression:  -8787652898496  =  fffff801`f7121140
0:  kd>  !vtop  1ab000  fffff801f7121140
Amd64VtoP:  Virt  fffff801`f7121140,  pagedir  1ab000
Amd64VtoP:  PML4E  1abf80
Amd64VtoP:  PDPE  3b09038
Amd64VtoP:  PDE  3b0adc0
Amd64VtoP:  Large  page  mapped  phys  00000002`18121140
Virtual  address  fffff801f7121140  translates  to  physical  address  218121140.

0:  kd>  !vtop  2f00000  fffff801f7121140
Amd64VtoP:  Virt  fffff801`f7121140,  pagedir  2f00000
Amd64VtoP:  PML4E  2f00f80
Amd64VtoP:  PDPE  eb3038
Amd64VtoP:  PDE  ab2dc0
Amd64VtoP:  PTE  eb9908
Amd64VtoP:  Mapped  phys  00000002`18121140
Virtual  address  fffff801f7121140  translates  to  physical  address  218121140.
  而比较重要的nt!KiSystemCall64Shadow，在2个表中都有映射，指向同一物理地址218121140

0:  kd>  !pcr
KPCR  for  Processor  0  at  fffff801f5b22000:
        Major  1  Minor  1
                NtTib.ExceptionList:  fffff801f9664fb0
                        NtTib.StackBase:  fffff801f9663000
                      NtTib.StackLimit:  0000000000000000
                  NtTib.SubSystemTib:  fffff801f5b22000
                            NtTib.Version:  00000000f5b22180
                    NtTib.UserPointer:  fffff801f5b22870
                            NtTib.SelfTib:  00000058e0504000

                                        SelfPcr:  0000000000000000
                                              Prcb:  fffff801f5b22180
                                              Irql:  0000000000000000
                                                IRR:  0000000000000000
                                                IDR:  0000000000000000
                            InterruptMode:  0000000000000000
                                                IDT:  0000000000000000
                                                GDT:  0000000000000000
                                                TSS:  0000000000000000

                            CurrentThread:  fffff801f72a4380
                                  NextThread:  0000000000000000
                                  IdleThread:  fffff801f72a4380

                                    DpcQueue:  Unable  to  read  nt!_KDPC_DATA.DpcListHead.Flink  @  fffff801f5b24f80

0:  kd>  !vtop  2f00000  fffff801f5b24f80
Amd64VtoP:  Virt  fffff801`f5b24f80,  pagedir  2f00000
Amd64VtoP:  PML4E  2f00f80
Amd64VtoP:  PDPE  eb3038
Amd64VtoP:  PDE  ab2d68
Amd64VtoP:  PTE  37b6920
Amd64VtoP:  zero  PTE
Virtual  address  fffff801f5b24f80  translation  fails,  error  0xD0000147.

0:  kd>  !vtop  1ab000  fffff801f5b24f80
Amd64VtoP:  Virt  fffff801`f5b24f80,  pagedir  1ab000
Amd64VtoP:  PML4E  1abf80
Amd64VtoP:  PDPE  3b09038
Amd64VtoP:  PDE  3b0ad68
Amd64VtoP:  PTE  510d920
Amd64VtoP:  Mapped  phys  f88f80
Virtual  address  fffff801f5b24f80  translates  to  physical  address  f88f80.

而另一个内核地址，只在R0被影射为物理地址f88f80.而在R3没有映射

提示错误  Virtual  address  fffff801f5b24f80  translation  fails,  error  0xD0000147.

与其说这是个漏洞，不如说这是个福音，微软这个死垃圾厚脸无耻把驱动圈起来收钱，补丁不用打了，我正研究怎么实现这个漏洞，玩一玩windows10这个垃圾系统

wx_邱晖 与其说这是个漏洞，不如说这是个福音，微软这个死垃圾厚脸无耻把驱动圈起来收钱，补丁不用打了，我正研究怎么实现这个漏洞，玩一玩windows10这个垃圾系统

神tm福音