VT 基本框架

已于 2023-02-28 14:45:12 修改
阅读量544 收藏 2
点赞数
分类专栏： VT win10x64 21H2 文章标签： 硬件架构 windows 系统安全 c语言
于 2023-02-26 20:50:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23389971/article/details/129231384
版权
VT 基本框架

目录

1.查询CPU对VMX的支持

  • cpuid 指令，查询1号功能，返回的ECX[5]==1
  •   #define CPUID_ECX_VMX_ABILITY (1<<5)
  ULONG64 CheckCPUID() {

      int ctx[4] = { 0 };//顺序：eax,ebx,ecx,edx
      __cpuid(ctx, 1);

      return ctx[2] & CPUID_ECX_VMX_ABILITY;	//Bit-5
  }
  • rdmsr 指令，查询BIOS是否已开启对VMX的支持
  •   #define MSR_IA32_FEATURE_CONTROL 0x3A
  ULONG64 CheckMsr() {

      MSR_IA32_FEATURE_CONTROL_REGISTER msr = { 0 };
      msr.value.QuadPart = __readmsr(MSR_IA32_FEATURE_CONTROL);

      return msr.Bits.Lock;
  }

2.开启VMX

  • 修正CR0和CR4，设置CR4.VMXE=1
  •   #define	MSR_IA32_VMX_CR0_FIXED0				0x486
  #define	MSR_IA32_VMX_CR0_FIXED1				0x487
  #define	MSR_IA32_VMX_CR4_FIXED0				0x488
  #define	MSR_IA32_VMX_CR4_FIXED1				0x489
  ULONG64 FixCr0() {

      IA32_CR0 uCr0 = { 0 };
      uCr0.value.QuadPart = __readcr0();

      uCr0.value.QuadPart |= __readmsr(MSR_IA32_VMX_CR0_FIXED0);
      uCr0.value.QuadPart &= __readmsr(MSR_IA32_VMX_CR0_FIXED1);

      __writecr0(uCr0.value.QuadPart);
      return TRUE;
  }
  ULONG64 FixCr4() {

      IA32_CR4 uCr4 = { 0 };
      uCr4.value.QuadPart = __readcr4();

      uCr4.value.QuadPart |= __readmsr(MSR_IA32_VMX_CR4_FIXED0);
      uCr4.value.QuadPart &= __readmsr(MSR_IA32_VMX_CR4_FIXED1);
      uCr4.Bits.VMXE = 1;

      __writecr4(uCr4.value.QuadPart);
      return TRUE;
  }

3.申请内存

  • VMON区，需要页对齐，并且需要得到它的物理地址
  • VMCS区，需要页对齐，并且需要得到它的物理地址
  • VMM栈，可以的话申请几个页，避免栈溢出
  •   ULONG64 CreateVM(UCHAR CpuIndex) {

      psVM[CpuIndex].pOnVa = ExAllocatePool2(POOL_FLAG_NON_PAGED, PAGE_SIZE, 'VMON');
      if (!psVM[CpuIndex].pOnVa) { return FALSE; }
      RtlZeroMemory(psVM[CpuIndex].pOnVa, PAGE_SIZE);
      psVM[CpuIndex].pOnPa = MmGetPhysicalAddress(psVM[CpuIndex].pOnVa);

      psVM[CpuIndex].pCsVa = ExAllocatePool2(POOL_FLAG_NON_PAGED, PAGE_SIZE, 'VMCS');
      if (!psVM[CpuIndex].pCsVa) { return FALSE; }
      RtlZeroMemory(psVM[CpuIndex].pCsVa, PAGE_SIZE);
      psVM[CpuIndex].pCsPa = MmGetPhysicalAddress(psVM[CpuIndex].pCsVa);

      psVM[CpuIndex].pStack = ExAllocatePool2(POOL_FLAG_NON_PAGED, STACK_SIZE, 'VMSK');
      if (!psVM[CpuIndex].pStack) { return FALSE; }
      RtlZeroMemory(psVM[CpuIndex].pStack, STACK_SIZE);

      return TRUE;
  }

4.设置VMXON区，执行VMXON

  • 只需要填写一个版本号
  • 执行vmxon(VMON区的物理地址);
  •   ULONG64 InitVmxON(UCHAR CpuIndex, ULONG RevisonId) {

      *((PULONG)psVM[CpuIndex].pOnVa) = RevisonId;

      if (__vmx_on(&psVM[CpuIndex].pOnPa.QuadPart))
      {
          KdPrint(("vmx_on 失败！\n"));
          return FALSE;
      }

      return TRUE;
  }

5.设置VMXCS区

  • 5.1.初始化VMCS
  •       ULONG64 InitVmxCS(UCHAR CpuIndex, ULONG RevisonId) {

          *((PULONG)psVM[CpuIndex].pCsVa) = RevisonId;

          if (__vmx_vmclear(&psVM[CpuIndex].pCsPa.QuadPart))
              return FALSE;
          if (__vmx_vmptrld(&psVM[CpuIndex].pCsPa.QuadPart))
              return FALSE;

          return TRUE;
      }
  • 2.设置GUEST运行环境
    • 控制寄存器：CR0,CR3,CR4
    • 调试寄存器：DR7
    • 段寄存器：ES,FS,DS,CS,SS,GS,TR,LDTR
    • GS基址,FS基址
    • GDT基址,IDT基址
    • GDT段限,IDT段限
    • 状态寄存器：RFLAGS
    • SYSENTER_CS,SYSENTER_ESP,SYSENTER_EIP
    • RIP,RSP
    • 需要保存GUEST当前的RSP和GUEST当前下一条指令的RIP，以便操作完成后回到GUEST的代码流程，就像没有发生过什么事一样
    •   ULONG64 SetGuestState(ULONG64 GuestRip, ULONG64 GuestRsp) {

      ULONG64 ret = 0;

      ULONG64 GdtBase = _readBaseGDT();
      ULONG64 IdtBase = _readBaseIDT();

      ret += __vmx_vmwrite(GUEST_CR0, __readcr0());
      ret += __vmx_vmwrite(GUEST_CR3, __readcr3());
      ret += __vmx_vmwrite(GUEST_CR4, __readcr4());
      ret += __vmx_vmwrite(GUEST_DR7, __readdr(7));

      ret += SetGuestSeg(ES, _readES(), GdtBase);
      ret += SetGuestSeg(FS, _readFS(), GdtBase);
      ret += SetGuestSeg(DS, _readDS(), GdtBase);
      ret += SetGuestSeg(CS, _readCS(), GdtBase);
      ret += SetGuestSeg(SS, _readSS(), GdtBase);
      ret += SetGuestSeg(GS, _readGS(), GdtBase);
      ret += SetGuestSeg(TR, _readTR(), GdtBase);
      ret += SetGuestSeg(LDTR, _readLDTR(), GdtBase);

      ret += __vmx_vmwrite(GUEST_FS_BASE, __readmsr(MSR_IA32_FS_BASE));
      ret += __vmx_vmwrite(GUEST_GS_BASE, __readmsr(MSR_IA32_GS_BASE));
      ret += __vmx_vmwrite(GUEST_GDTR_BASE, GdtBase);
      ret += __vmx_vmwrite(GUEST_GDTR_LIMIT, _readLimitGDT());
      ret += __vmx_vmwrite(GUEST_IDTR_BASE, IdtBase);
      ret += __vmx_vmwrite(GUEST_IDTR_LIMIT, _readLimitIDT());

      ret += __vmx_vmwrite(GUEST_RFLAGS, __readeflags());
      ret += __vmx_vmwrite(GUEST_RIP, GuestRip);
      ret += __vmx_vmwrite(GUEST_RSP, GuestRsp);

      ret += __vmx_vmwrite(GUEST_IA32_SYSENTER_CS, __readmsr(MSR_IA32_SYSENTER_CS));
      ret += __vmx_vmwrite(GUEST_IA32_SYSENTER_ESP, __readmsr(MSR_IA32_SYSENTER_ESP));
      ret += __vmx_vmwrite(GUEST_IA32_SYSENTER_EIP, __readmsr(MSR_IA32_SYSENTER_EIP));

      return ret;
  }
  • 3.设置HOST运行环境
    • 控制寄存器：CR0,CR3,CR4
    • 段寄存器：ES,FS,DS,CS,SS,GS,TR
    • GS基址,FS基址,TR基址
    • GDT基址,IDT基址
    • SYSENTER_CS,SYSENTER_ESP,SYSENTER_EIP
    • RIP,RSP
    • HOST的RIP就是VM退出后跳转到VMM的入口地址，所以我们要写一个VMM入口函数，保存VM的现场状态，回到VM后才能继续像什么也没发生过一样继续执行
    •     ULONG64 SetHostState(ULONG64 HostRip, ULONG64 HostRsp) {

        SEG seg = { 0 };
        ULONG64 ret = 0;
        ULONG64 GdtBase = _readBaseGDT();
        ULONG64 IdtBase = _readBaseIDT();
        ULONG64 TR = GetSegInfo(&seg, _readTR(), GdtBase);

        ret += __vmx_vmwrite(HOST_CR0, __readcr0());
        ret += __vmx_vmwrite(HOST_CR3, __readcr3());
        ret += __vmx_vmwrite(HOST_CR4, __readcr4());

        ret += __vmx_vmwrite(HOST_RIP, HostRip);
        ret += __vmx_vmwrite(HOST_RSP, HostRsp);

        ret += __vmx_vmwrite(HOST_CS_SELECTOR, _readCS() & 0xF8);
        ret += __vmx_vmwrite(HOST_SS_SELECTOR, _readSS() & 0xF8);
        ret += __vmx_vmwrite(HOST_DS_SELECTOR, _readDS() & 0xF8);
        ret += __vmx_vmwrite(HOST_ES_SELECTOR, _readES() & 0xF8);
        ret += __vmx_vmwrite(HOST_FS_SELECTOR, _readFS() & 0xF8);
        ret += __vmx_vmwrite(HOST_GS_SELECTOR, _readGS() & 0xF8);
        ret += __vmx_vmwrite(HOST_TR_SELECTOR, _readTR() & 0xF8);

        ret += __vmx_vmwrite(HOST_FS_BASE, __readmsr(MSR_IA32_FS_BASE));
        ret += __vmx_vmwrite(HOST_GS_BASE, __readmsr(MSR_IA32_GS_BASE));
        ret += __vmx_vmwrite(HOST_TR_BASE, TR ? seg.Base : 0);
        ret += __vmx_vmwrite(HOST_GDTR_BASE, GdtBase);
        ret += __vmx_vmwrite(HOST_IDTR_BASE, IdtBase);

        ret += __vmx_vmwrite(HOST_IA32_SYSENTER_CS, __readmsr(MSR_IA32_SYSENTER_CS));
        ret += __vmx_vmwrite(HOST_IA32_SYSENTER_ESP, __readmsr(MSR_IA32_SYSENTER_ESP));
        ret += __vmx_vmwrite(HOST_IA32_SYSENTER_EIP, __readmsr(MSR_IA32_SYSENTER_EIP));

        return ret;
    }
  • 4.设置执行控制
    • 先设置最基本的的条件
    •     ULONG64 SetVmxExecutionCTLS(UCHAR CpuIndex, ULONG64 vmxctrl) {

        UCHAR ret = 0;
        ULONG64 value = 0;

        MSR_IA32_VMX_PINBASED_CTLS_REGISTER PinBased = { 0 }, SetPinBase = { 0 };
        MSR_IA32_VMX_PROCBASED_CTLS_REGISTER Primary = { 0 }, SetPrimary = { 0 };
        MSR_IA32_VMX_PROCBASED_CTLS2_REGISTER Secondry = { 0 }, SetSecondry = { 0 };
        MSR_IA32_VMX_PROCBASED_CTLS3_REGISTER Tertiary = { 0 };

        PinBased.value.QuadPart = vmxctrl ? __readmsr(MSR_IA32_VMX_TRUE_PINBASED_CTLS) : __readmsr(MSR_IA32_VMX_PINBASED_CTLS);
        /*在这里设置《PinBased》*/

        value = SetControls(SetPinBase.value.QuadPart, PinBased.value);
        ret += __vmx_vmwrite(PIN_BASED_VM_EXECUTION_CONTROLS, value);

        Primary.value.QuadPart = vmxctrl ? __readmsr(MSR_IA32_VMX_TRUE_PROCBASED_CTLS) : __readmsr(MSR_IA32_VMX_PROCBASED_CTLS);
        /*在这里设置《Primary》*/
        SetPrimary.Bits->MSRmap = TRUE;
        SetPrimary.Bits->RDTSC = TRUE;
        SetPrimary.Bits->Secondary = TRUE;

        value = SetControls(SetPrimary.value.QuadPart, Primary.value);
        ret += __vmx_vmwrite(PRIMARY_PROCESSOR_BASED_VM_EXECUTION_CONTROLS, value);

        if (SetPrimary.Bits->Secondary)
        {
            Secondry.value.QuadPart = __readmsr(MSR_IA32_VMX_PROCBASED_CTLS2);

            /*在这里设置《Secondry》*/
            SetSecondry.Bits->XSAVES_XRSTORS = TRUE;
            SetSecondry.Bits->INVPCID = TRUE;
            SetSecondry.Bits->RDTSCP = TRUE;

            value = SetControls(SetSecondry.value.QuadPart, Secondry.value);
            ret += __vmx_vmwrite(SECONDARY_PROCESSOR_BASED_VM_EXECUTION_CONTROLS, value);

        }
        
        ret += __vmx_vmwrite(VMCS_LINK_POINTER_FULL, ~0Ull);
        ret += __vmx_vmwrite(VIRTUAL_PROCESSOR_IDENTIFIER, CpuIndex);

        return ret;
    }
  • 5.设置VM退出控制
    • 先设置最基本的的条件
    •     ULONG64 SetVmxExitCTLS(UCHAR CpuIndex, ULONG64 vmxctrl) {

        ULONG64 ret = 0;            
        ULONG64 value = 0;
        MSR_IA32_VMX_EXIT_CTLS_REGISTER VmExit = { 0 }, SetExit = { 0 };
        VmExit.value.QuadPart = vmxctrl ? __readmsr(MSR_IA32_VMX_TRUE_EXIT_CTLS) : __readmsr(MSR_IA32_VMX_EXIT_CTLS);
        /*在这里设置《VmExit》*/
        SetExit.Bits->HOST_addr_size = TRUE;

        value = SetControls(SetExit.value.QuadPart, VmExit.value);
        ret += __vmx_vmwrite(PRIMARY_VM_EXIT_CONTROLS, value);

        return ret;
    }
  • 6.设置VM进入控制
    • 先设置最基本的的条件
    •     ULONG64 SetVmxEntryCTLS(UCHAR CpuIndex, ULONG64 vmxctrl) {

        ULONG64 ret = 0;
        ULONG64 value = 0;
        MSR_IA32_VMX_ENTRY_CTLS_REGISTER VmEntry = { 0 }, SetEntry = { 0 };
        VmEntry.value.QuadPart = vmxctrl ? __readmsr(MSR_IA32_VMX_TRUE_ENTRY_CTLS) : __readmsr(MSR_IA32_VMX_ENTRY_CTLS);
        /*在这里设置《VmEntry》*/
        SetEntry.Bits->Guest_IA32e = TRUE;

        value = SetControls(SetEntry.value.QuadPart, VmEntry.value);
        ret += __vmx_vmwrite(VM_ENTRY_CONTROLS, value);

        return ret;
    }
  • 7.编写VMM处理函数
    • 此函数只做一些准备工作。
    •     ULONG64 HostEntry(PGUESTREG pGuestRegs)
    {
        __vmx_vmread(VIRTUAL_PROCESSOR_IDENTIFIER, &pGuestRegs->CpuIndex);
        __vmx_vmread(EXIT_REASON,  (size_t*) & pGuestRegs->exitReason);

        __vmx_vmread(GUEST_RIP, &pGuestRegs->GuestRip);
        __vmx_vmread(GUEST_RSP, &pGuestRegs->GuestRsp);
        __vmx_vmread(GUEST_RFLAGS, &pGuestRegs->GuestFlag);
        __vmx_vmread(VM_EXIT_INSTRUCTION_LENGTH, &pGuestRegs->InstrLen);

        pGuestRegs->eProcess = PsGetCurrentProcess();
        pGuestRegs->eThread = PsGetCurrentThread();

        return DispatchHandler(pGuestRegs);
    }
    • 调用 DispatchHandler 来处理事件。以下只是处理一些必须要处理的指令，CPU不同可能会有差异。处理方法就是查看CPU手册，模仿指令行为。这里就省略了，以免读者看得不清晰
    •     ULONG64 DispatchHandler(PGUESTREG pGuestRegs)
    {
        EXIT_REASON_FIELDS* exit = (EXIT_REASON_FIELDS*)&pGuestRegs->exitReason;
        ULONG64 CpuIndex = pGuestRegs->CpuIndex;
        ULONG64 GuestRip = pGuestRegs->GuestRip;
        ULONG64 GuestRsp = pGuestRegs->GuestRsp;
        ULONG64 InstrLen = pGuestRegs->InstrLen;

        switch (exit->Bits.Basic)
        {
        case EXIT_REASON_CPUID: {
           ...
            break;
        }
        case EXIT_REASON_RDMSR: {
           ...
            break;
        }
        case EXIT_REASON_WRMSR: {
           ...
            break;
        }
        case EXIT_REASON_RDTSC: {
            ...
            break;
        }
        case EXIT_REASON_RDTSCP: {
           ...
            break;
        }                           
        default:
            DbgBreakPoint();
            break;
        }
        return TRUE;
    }

6.执行VM

  • 执行vmlaunch();
  • 如果上述设置没有出现问题。代码会接着在我们设置好的GUEST.RIP处继续运行。直到触发VM退出条件，即可进入我们设置好的VMM.RIP（HostEntry）处开始执行

<源码下载>

<源码>

小烟囱
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
VT笔记(2)突破patchguard保护完成X64Hook
kernweak的博客
06-24 8679
win10，2018新年版后好像不支持了？ MSR hook MSR (Model Specific Registers)是CPU 的一组64 位寄存器，可以分别通过RDMSR 和WRMSR 两条指令进行读和写的操作，前提要在ECX 中写入MSR 的地址(MSR地址就像一个宏STAR，LSTAR，CSTAR，SFMASK)。对于RDMSR 指令，将会返回相应的MSR 中64bit 信息到(ED...
VT-E03固件
10-05
update_300085_chuangwei_E03_1.02.09.020_2015.2.15 广东联通固件，需要广东联通账号
VT win10x64 21H2 基础框架
02-27
VT win10x64 21H2 基础框架
unbuntu终端VT码使用方法与基本参数
05-16
文档是VIM编辑的，直接用文本打开排版会很乱，建议使用Notepad++ 打开。文档主要是unbuntu终端的VT用法和一些基本参数。
VT System中文使用指导手册
08-01
此文档是Vector编制的VT System中文使用指导手册。
VT虚拟化框架编写
鬼手的博客
02-11 5108
学习VT相关的知识，需要具备WIN32基础和内核相关的知识，包括Windows段机制，页机制等等，VT里面都会有所涉及，也就是得把Windows编程和驱动基本通关，新手建议劝退。整个VT的知识结构有大量的新的概念，新的寄存器，新的指令还有各种标志位，初次学习VT建议结合代码来理解相关的理论基础，重点在于梳理整个VT的流程，不要深究具体的某个细节。整个流程走完之后就有了阅读别人代码的能力，等实际应用的时候再去查阅相关资料补齐技术细节的部分。我的笔记，很多能省的基本都省掉了，只把整体必须的流程整理出来。
VT虚拟化框架X64
03-30
因特尔VT虚拟化框架，支持WIN764位系统，多核操作系统。
Intel VT学习笔记（七）—— EPT物理地址转换
qq_41988448的博客
02-21 1424
Intel VT学习笔记（七）—— EPT物理地址转换要点回顾EPT支持检测参考资料 要点回顾 在上一篇中，已经初步实现了最小VT框架，但实际上还有许多问题需要解决。 在最小VT框架中，我们仅处理了三个退出码： #define EXIT_REASON_CPUID 10 #define EXIT_REASON_VMCALL 18 #define EXIT_REASON_CR_ACCESS 28 要是想开发一个成熟的VT框架，需要处理的
SV/UVM 学习笔记13（TLM通信）
Aniran的博客
06-04 880
目的：为了节省编写通信相关代码的精力，为了各个模块的封装性。需要为两个模块之间建立一个专用通道，同时这个通道能协调不同处理速度的模块的阻塞或非阻塞的收发方式（FIFO）。为此产生了TLM通信。 一般过程：TLM端口分为port export import，这体现的是控制的发起者和接受者，并非数据的实际流向其中port具有最高优先级，而import是最低优先级。按照数据流向可以分为三种：put、get、peek、transport。其中transport相当于一次put和一次get(因此有两个参数),这三种
vTESTstudio - VT System CAPL Functions - General/Trigger Function
车载网络测试
02-13 711
VT System调用基础函数控制VT板卡介绍
3_基本框架_VMXON
leibso的博客
10-14 215
原理参考 3卷 23.7节等 本节实施流程参考Intel手册： 3卷 31.5节 1 vt整体框架; 首先 开锁： 1 开启 Cr4.[VMXE]: 上一节，检测了 VMX 需要的环境；最后一个 CR4.[13/VMXE] 只检测了是否已经被开启（有别的虚拟机）； 但是 没有在 CR4.[13/VMXE] ==0 的时候去开启。 所以 这里 开始 开...
VT驱动开发
数据安全学习分享
11-29 1319
VT技术是Intel提供的虚拟化技术，全称为Intel Virtualization Technology。它是一套硬件和软件的解决方案，旨在增强虚拟化环境的性能、可靠性和安全性。VT技术允许在一台物理计算机上同时运行多个虚拟机，每个虚拟机都可以运行不同的操作系统和应用程序。
Intel处理器虚拟化技术VT-x86下实现小型虚拟化框架（1）
最新发布
qq_30528603的博客
02-24 908
我一直觉得，学习计算机中的一门新技术，一定要从历史去了解他的全貌。这样有利于我们了解事情的来龙去脉和发展的过程。一上来直接接触新兴事物，很容易陷入不知从何下手的困境。不了解历史发展，就不明白前人的一些操作。因此，这个系列的博客将详细完整记录VT（处理器虚拟化技术）的一些细节包括简单实现。单纯是对这门技术的兴趣。二.虚拟化技术的介绍以及历史虚拟化的诞生对计算机的发展是巨大的。好比如我们经常用的虚拟机VMware Workstation，VirtualBox等出名的虚拟化软件。都是基于这个技术去实现的。
开源框架VTMagic的使用介绍
weixin_34185560的博客
06-13 188
2019独角兽企业重金招聘Python工程师标准>>> ...
VT虚拟化驱动入门教程
吾无法无天的博客
11-10 6979
手把手教VT驱动框架编写及 无视检测和PG的无痕HOOK
VT-Unet代码框架
越秃越强
05-24 728
VT-Unet代码大体流程如下 对应embded_dim = 48 vt_unet.py文件
开源项目-基于Intel VT技术的Linux内核调试器
陈莉君的专栏
08-09 5158
本开源项目将硬件虚拟化技术应用在内核调试器上，使内核调试器成为VMM，将操作系统置于虚拟机中运行，即操作系统成为GuestOS，以这样的一种形式进行调试，最主要的好处就是调试器对操作系统完全透明。如下图：        图1 虚拟化调试器框架     传统的内核调试器的工作原理是接管中断向量表中的INT1和INT3处理程序。前者对应的是 #DB异常，通常是设置了单步标志后引发的
Intel VT入门
codemanrock
04-23 5550
前言     传说中的VT貌似很神秘的样子,关于VT入门的资料又很少,于是研究了一番 由于资源有限,自身水平亦有限,并且是闭门造车之作,如有错误的地方请指正,不胜感激! 关于VT可以先参考海风月影写的关于VT调试器http://bbs.pediy.com/showthread.php?t=96122   运行环境 操作系统: windows XP  CPU : intel i3-
vt distribution
05-01
vt distribution是什么？ vt distribution是一种文件分发技术，它使用云端验证技术来检查文件是否有病毒，以保证文件的安全性。这种技术可以有效地防止和识别恶意软件，保护个人用户和企业的系统安全。这种技术可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小烟囱

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值