进程与桌面交互

最新推荐文章于 2020-06-28 14:12:36 发布
最新推荐文章于 2020-06-28 14:12:36 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： 开发总结 文章标签： descriptor null access security buffer header

CreateProcessAsUser() windowstations 和桌面 收藏

<script type="text/javascript"> document.body.oncopy = function() { if (window.clipboardData) { setTimeout(function() { var text = clipboardData.getData("text"); if (text && text.length>300) { text = text + "/r/n/n本文来自CSDN博客，转载请标明出处：" + location.href; clipboardData.setData("text", text); } }, 100); } } </script> <script class="blogstory">function StorePage(){d=document;t=d.selection?(d.selection.type!='None'?d.selection.createRange().text:''):(d.getSelection?d.getSelection():'');void(keyit=window.open('http://www.365key.com/storeit.aspx?t='+escape(d.title)+'&u='+escape(d.location.href)+'&c='+escape(t),'keyit','scrollbars=no,width=475,height=575,left=75,top=20,status=no,resizable=yes'));keyit.focus();}</script>

以下示例代码使用户名为 " franki " 完全访问权限交互 windowstation 桌面， " winsta0//default "。 对于每个对象访问控制项 (ACE) 是基于 franki 的登录 SID。 代码执行 Cmd.exe 文件。

# define RTN_OK     0
   #define RTN_ERROR 13

   #define WINSTA_ALL (WINSTA_ACCESSCLIPBOARD  | WINSTA_ACCESSGLOBALATOMS |
   WINSTA_CREATEDESKTOP     |  WINSTA_ENUMDESKTOPS       |
   WINSTA_ENUMERATE         |  WINSTA_EXITWINDOWS        |
   WINSTA_READATTRIBUTES    |  WINSTA_READSCREEN         |
   WINSTA_WRITEATTRIBUTES   |   DELETE                     |
   READ_CONTROL             |  WRITE_DAC                 |
   WRITE_OWNER)

    # define DESKTOP_ALL (DESKTOP_CREATEMENU      | DESKTOP_CREATEWINDOW  |
   DESKTOP_ENUMERATE        |  DESKTOP_HOOKCONTROL    |
   DESKTOP_JOURNALPLAYBACK  |  DESKTOP_JOURNALRECORD  |
   DESKTOP_READOBJECTS      |  DESKTOP_SWITCHDESKTOP  |
   DESKTOP_WRITEOBJECTS     |   DELETE                  |
   READ_CONTROL             |  WRITE_DAC              |
   WRITE_OWNER)

    # define GENERIC_ACCESS (GENERIC_READ    | GENERIC_WRITE |
   GENERIC_EXECUTE  |  GENERIC_ALL)

    # include <windows.h>
   #include <stdio.h>

   BOOL ObtainSid(

        HANDLE hToken ,             //  Handle to an process access token .
        PSID    * psid              //  ptr to the buffer of the logon sid
        );

   void RemoveSid(
        PSID  * psid                //  ptr to the buffer of the logon sid
        );

   BOOL AddTheAceWindowStation(

        HWINSTA hwinsta ,           //  handle to a windowstation
        PSID    psid              //  logon sid of the process
        );

   BOOL AddTheAceDesktop(

        HDESK hdesk ,               //  handle to a desktop
        PSID  psid                //  logon sid of the process
        );

    int  main(void)
   {
        HANDLE              hToken;
        HDESK               hdesk;
        HWINSTA             hwinsta;
        PROCESS_INFORMATION pi;
        PSID                psid;
        STARTUPINFO         si;

         //  
         //  obtain an access token  for  the user fester
         //  
         if  ( ! LogonUser(
              " franki " ,
             NULL ,
              " franki " ,
             LOGON32_LOGON_INTERACTIVE ,
             LOGON32_PROVIDER_DEFAULT ,
              & hToken
             ))
              return  RTN_ERROR;

         //  
         //  obtain a handle to the interactive windowstation
         //  
        hwinsta  =  OpenWindowStation(
              " winsta0 " ,
             FALSE ,
             READ_CONTROL  |  WRITE_DAC
             );
         if  (hwinsta  ==  NULL)
              return  RTN_ERROR;

        HWINSTA hwinstaold  =  GetProcessWindowStation();

         //  
         //  set the windowstation to winsta0 so that you obtain the
         //  correct default desktop
         //  
         if  ( ! SetProcessWindowStation(hwinsta))
              return  RTN_ERROR;

         //  
         //  obtain a handle to the  " default "  desktop
         //  
        hdesk  =  OpenDesktop(
              " default " ,
              0 ,
             FALSE ,
             READ_CONTROL  |  WRITE_DAC  |
             DESKTOP_WRITEOBJECTS  |  DESKTOP_READOBJECTS
             );
         if  (hdesk  ==  NULL)
              return  RTN_ERROR;

         //  
         //  obtain the logon sid of the user fester
         //  
         if  ( ! ObtainSid(hToken ,   & psid))
              return  RTN_ERROR;

         //  
         //  add the user to interactive windowstation
         //  
         if  ( ! AddTheAceWindowStation(hwinsta ,  psid))
              return  RTN_ERROR;

         //  
         //  add user to  " default "  desktop
         //  
         if  ( ! AddTheAceDesktop(hdesk ,  psid))
              return  RTN_ERROR;

         //  
         //  free the buffer  for  the logon sid
         //  
        RemoveSid( & psid);

         //  
         //   close  the handles to the interactive windowstation and desktop
         //  
        CloseWindowStation(hwinsta);

        CloseDesktop(hdesk);

         //  
         //  initialize STARTUPINFO structure
         //  
        ZeroMemory( & si ,  sizeof(STARTUPINFO));
        si . cb         =  sizeof(STARTUPINFO);
        si . lpDesktop  =   " winsta0/default " ;

         //  
         //  start the process
         //  
         if  ( ! CreateProcessAsUser(
             hToken ,
             NULL ,
              " cmd.exe " ,
             NULL ,
             NULL ,
             FALSE ,
             NORMAL_PRIORITY_CLASS  |  CREATE_NEW_CONSOLE ,
             NULL ,
             NULL ,
              & si ,
              & pi
             ))
              return  RTN_ERROR;

        SetProcessWindowStation(hwinstaold);  // set it back

         //  
         //   close  the handles
         //  
        CloseHandle(pi . hProcess);

        CloseHandle(pi . hThread);

         return  RTN_OK;
   }


   BOOL ObtainSid(HANDLE hToken ,  PSID  * psid)

      {
        BOOL                    bSuccess  =  FALSE;  //  assume function will
                                                   //  fail
        DWORD                   dwIndex;
        DWORD                   dwLength  =   0 ;
        TOKEN_INFORMATION_CLASS tic       =  TokenGroups;
        PTOKEN_GROUPS           ptg       =  NULL;

        __try
             {
              //  
              //  determine the size of the buffer
         //  
              if  ( ! GetTokenInformation(
             hToken ,
             tic ,
             (LPVOID)ptg ,
              0 ,
              & dwLength
             ))
                  {
                   if  (GetLastError()  ==  ERROR_INSUFFICIENT_BUFFER)
                       {
                       ptg  =  (PTOKEN_GROUPS)HeapAlloc(
                            GetProcessHeap() ,
                  HEAP_ZERO_MEMORY ,
                  dwLength
                  );
                        if  (ptg  ==  NULL)
                            __leave;
                       }
                    else
                       __leave;
         }

              //  
              //  obtain the groups the access token belongs to
              //  
              if  ( ! GetTokenInformation(
                  hToken ,
             tic ,
             (LPVOID)ptg ,
             dwLength ,
              & dwLength
             ))
                  __leave;

              //  
              //  determine which group is the logon sid
              //  
              for  (dwIndex  =   0 ; dwIndex  <  ptg -> GroupCount; dwIndex ++ )
                  {
              if  ((ptg -> Groups[dwIndex] . Attributes  &  SE_GROUP_LOGON_ID)
                   ==   SE_GROUP_LOGON_ID)
                       {
                        //  
                        //  determine the  length  of the sid
                        //  
                       dwLength  =  GetLengthSid(ptg -> Groups[dwIndex] . Sid);

                        //  
                        //  allocate a buffer  for  the logon sid
                        //  
                        * psid  =  (PSID)HeapAlloc(
                            GetProcessHeap() ,
                  HEAP_ZERO_MEMORY ,
                  dwLength
                  );
                   if  ( * psid  ==  NULL)
                       __leave;

                   //  
                   //  obtain a copy of the logon sid
                   //  
                   if  ( ! CopySid(dwLength ,   * psid ,  ptg -> Groups[dwIndex] . Sid))
                       __leave;

                   //  
                   //  break out of the loop because the logon sid has been
                   //  found
                   //  
                  break;
                  }
             }

              //  
              //  indicate success
              //  
             bSuccess  =  TRUE;
             }
        __finally
             {
              //  
         //  free the buffer  for  the token group
         //  
              if  (ptg  !=  NULL)
                  HeapFree(GetProcessHeap() ,   0 ,  (LPVOID)ptg);
             }

         return  bSuccess;

   }

   void RemoveSid(PSID  * psid)
   {
        HeapFree(GetProcessHeap() ,   0 ,  (LPVOID) * psid);
   }

   BOOL AddTheAceWindowStation(HWINSTA hwinsta ,  PSID psid)
   {

        ACCESS_ALLOWED_ACE    * pace;
        ACL_SIZE_INFORMATION aclSizeInfo;
        BOOL                 bDaclExist;
        BOOL                 bDaclPresent;
        BOOL                 bSuccess   =  FALSE;  //  assume function will
                                                 // fail
        DWORD                dwNewAclSize;
        DWORD                dwSidSize  =   0 ;
        DWORD                dwSdSizeNeeded;
        PACL                 pacl;
        PACL                 pNewAcl;
        PSECURITY_DESCRIPTOR psd        =  NULL;
        PSECURITY_DESCRIPTOR psdNew     =  NULL;
        PVOID                pTempAce;
        SECURITY_INFORMATION si         =  DACL_SECURITY_INFORMATION;
        unsigned  int          i;

        __try
             {
              //  
              //  obtain the dacl  for  the windowstation
              //  
              if  ( ! GetUserObjectSecurity(
                  hwinsta ,
              & si ,
             psd ,
                  dwSidSize ,
              & dwSdSizeNeeded
                  ))
              if  (GetLastError()  ==  ERROR_INSUFFICIENT_BUFFER)
                  {
                  psd  =  (PSECURITY_DESCRIPTOR)HeapAlloc(
                       GetProcessHeap() ,
                       HEAP_ZERO_MEMORY ,
                       dwSdSizeNeeded
             );
                   if  (psd  ==  NULL)
                       __leave;

                  psdNew  =  (PSECURITY_DESCRIPTOR)HeapAlloc(
                       GetProcessHeap() ,
                       HEAP_ZERO_MEMORY ,
                       dwSdSizeNeeded
                       );
                   if  (psdNew  ==  NULL)
                       __leave;

                  dwSidSize  =  dwSdSizeNeeded;

                   if  ( ! GetUserObjectSecurity(
                       hwinsta ,
                        & si ,
                       psd ,
                       dwSidSize ,
                        & dwSdSizeNeeded
                       ))
                       __leave;
         }
              else
                   __leave;

              //  
              //  create a new dacl
         //  
              if  ( ! InitializeSecurityDescriptor(
                  psdNew ,
                  SECURITY_DESCRIPTOR_REVISION
                  ))
                  __leave;

              //  
         //  get dacl from the security descriptor
              //  
              if  ( ! GetSecurityDescriptorDacl(
                  psd ,
                   & bDaclPresent ,
                   & pacl ,
                   & bDaclExist
                  ))
                  __leave;

              //  
              //  initialize
              //  
             ZeroMemory( & aclSizeInfo ,  sizeof(ACL_SIZE_INFORMATION));
             aclSizeInfo . AclBytesInUse  =  sizeof(ACL);

              //  
              //  call only  if  the dacl is not NULL
              //  
              if  (pacl  !=  NULL)
                  {
                   //  get the file ACL size info
                   if  ( ! GetAclInformation(
                       pacl ,
                       (LPVOID) & aclSizeInfo ,
                       sizeof(ACL_SIZE_INFORMATION) ,
                       AclSizeInformation
                       ))
                       __leave;
                   }

              //  
              //  compute the size of the new acl
              //  
             dwNewAclSize  =  aclSizeInfo . AclBytesInUse  +  ( 2   *
             sizeof(ACCESS_ALLOWED_ACE))  +  ( 2   *  GetLengthSid(psid))  -  ( 2   *
             sizeof(DWORD));

              //  
              //  allocate memory  for  the new acl
              //  
             pNewAcl  =  (PACL)HeapAlloc(
                  GetProcessHeap() ,
                  HEAP_ZERO_MEMORY ,
                  dwNewAclSize
                  );
              if  (pNewAcl  ==  NULL)
                  __leave;

              //  
              //  initialize the new dacl
              //  
              if  ( ! InitializeAcl(pNewAcl ,  dwNewAclSize ,  ACL_REVISION))
                  __leave;

              //  
              //   if  DACL is present ,  copy it to a new DACL
              //  
              if  (bDaclPresent)  //  only copy  if  DACL was present
                  {
                   //  copy the ACEs to  our  new ACL
                   if  (aclSizeInfo . AceCount)
                       {
                        for  (i = 0 ; i  <  aclSizeInfo . AceCount; i ++ )
                            {
                             //  get an ACE
                             if  ( ! GetAce(pacl ,  i ,   & pTempAce))
                                 __leave;

                             //  add the ACE to the new ACL
                             if  ( ! AddAce(
                  pNewAcl ,
                                 ACL_REVISION ,
                                 MAXDWORD ,
                                 pTempAce ,
                  ((PACE_HEADER)pTempAce) -> AceSize
                                 ))
                                 __leave;
                             }
                        }
                  }

              //  
              //  add the first ACE to the windowstation
              //  
             pace  =  (ACCESS_ALLOWED_ACE  * )HeapAlloc(
                  GetProcessHeap() ,
                  HEAP_ZERO_MEMORY ,
             sizeof(ACCESS_ALLOWED_ACE)  +  GetLengthSid(psid)  -
                  sizeof(DWORD
                  ));
              if  (pace  ==  NULL)
                  __leave;

             pace -> Header . AceType   =  ACCESS_ALLOWED_ACE_TYPE;
             pace -> Header . AceFlags  =  CONTAINER_INHERIT_ACE  |
                                     INHERIT_ONLY_ACE       |

                                     OBJECT_INHERIT_ACE;
             pace -> Header . AceSize   =  sizeof(ACCESS_ALLOWED_ACE)  +

                                     GetLengthSid(psid)  -  sizeof(DWORD);
             pace -> Mask             =  GENERIC_ACCESS;

              if  ( ! CopySid(GetLengthSid(psid) ,   & pace -> SidStart ,  psid))
                  __leave;

              if  ( ! AddAce(
                  pNewAcl ,
                  ACL_REVISION ,
             MAXDWORD ,
                  (LPVOID)pace ,
                  pace -> Header . AceSize
                  ))
                  __leave;

              //  
              //  add the second ACE to the windowstation
              //  
             pace -> Header . AceFlags  =  NO_PROPAGATE_INHERIT_ACE;
             pace -> Mask             =  WINSTA_ALL;

              if  ( ! AddAce(
                  pNewAcl ,
                  ACL_REVISION ,
                  MAXDWORD ,
                  (LPVOID)pace ,
                  pace -> Header . AceSize
                  ))
                  __leave;

                   //  
                   //  set new dacl  for  the security descriptor
                   //  
                   if  ( ! SetSecurityDescriptorDacl(
                       psdNew ,
                       TRUE ,
                       pNewAcl ,
                       FALSE
                       ))
                       __leave;

                    //  
          //  set the new security descriptor  for  the windowstation
          //  
          if  ( ! SetUserObjectSecurity(hwinsta ,   & si ,  psdNew))
            __leave;

          //  
          //  indicate success
          //  
         bSuccess  =  TRUE;
             }
        __finally
             {
              //  
              //  free the allocated buffers
              //  
              if  (pace  !=  NULL)
                  HeapFree(GetProcessHeap() ,   0 ,  (LPVOID)pace);

              if  (pNewAcl  !=  NULL)
                  HeapFree(GetProcessHeap() ,   0 ,  (LPVOID)pNewAcl);

              if  (psd  !=  NULL)
                  HeapFree(GetProcessHeap() ,   0 ,  (LPVOID)psd);

              if  (psdNew  !=  NULL)
                  HeapFree(GetProcessHeap() ,   0 ,  (LPVOID)psdNew);
             }

         return  bSuccess;

   }

   BOOL AddTheAceDesktop(HDESK hdesk ,  PSID psid)
   {

        ACL_SIZE_INFORMATION aclSizeInfo;
        BOOL                 bDaclExist;
        BOOL                 bDaclPresent;
        BOOL                 bSuccess   =  FALSE;  //  assume function will
                                                 //  fail
        DWORD                dwNewAclSize;
        DWORD                dwSidSize  =   0 ;
        DWORD                dwSdSizeNeeded;
        PACL                 pacl;
        PACL                 pNewAcl;
        PSECURITY_DESCRIPTOR psd        =  NULL;
        PSECURITY_DESCRIPTOR psdNew     =  NULL;
        PVOID                pTempAce;
        SECURITY_INFORMATION si         =  DACL_SECURITY_INFORMATION;
        unsigned  int          i;

        __try
             {
              //  
              //  obtain the security descriptor  for  the desktop object
              //  
              if  ( ! GetUserObjectSecurity(
                  hdesk ,
                   & si ,
                  psd ,
                  dwSidSize ,
                   & dwSdSizeNeeded
                  ))
                  {
                   if  (GetLastError()  ==  ERROR_INSUFFICIENT_BUFFER)
                       {
                       psd  =  (PSECURITY_DESCRIPTOR)HeapAlloc(
                            GetProcessHeap() ,
                            HEAP_ZERO_MEMORY ,
             dwSdSizeNeeded
             );
                        if  (psd  ==  NULL)
                            __leave;

                       psdNew  =  (PSECURITY_DESCRIPTOR)HeapAlloc(
                            GetProcessHeap() ,
                            HEAP_ZERO_MEMORY ,
                            dwSdSizeNeeded
             );
                        if  (psdNew  ==  NULL)
                            __leave;

                       dwSidSize  =  dwSdSizeNeeded;

                        if  ( ! GetUserObjectSecurity(
                            hdesk ,
                             & si ,
                            psd ,
                            dwSidSize ,
                             & dwSdSizeNeeded
                            ))
                            __leave;
                       }
                   else
                       __leave;
                  }

              //  
              //  create a new security descriptor
              //  
              if  ( ! InitializeSecurityDescriptor(
                  psdNew ,
                  SECURITY_DESCRIPTOR_REVISION
                  ))
               _   _leave;

              //  
              //  obtain the dacl from the security descriptor
              //  
              if  ( ! GetSecurityDescriptorDacl(
                  psd ,
                   & bDaclPresent ,
                   & pacl ,
                   & bDaclExist
                  ))
                  __leave;

              //  
              //  initialize
              //  
             ZeroMemory( & aclSizeInfo ,  sizeof(ACL_SIZE_INFORMATION));
             aclSizeInfo . AclBytesInUse  =  sizeof(ACL);

              //  
              //  call only  if  NULL dacl
              //  
              if  (pacl  !=  NULL)
                  {
                   //  
                   //  determine the size of the ACL info
                   //  
                   if  ( ! GetAclInformation(
                       pacl ,
                       (LPVOID) & aclSizeInfo ,
                       sizeof(ACL_SIZE_INFORMATION) ,
                       AclSizeInformation
                       ))
                       __leave;
                   }

              //  
              //  compute the size of the new acl
              //  
        dwNewAclSize  =  aclSizeInfo . AclBytesInUse  +
                            sizeof(ACCESS_ALLOWED_ACE)  +
                            GetLengthSid(psid)  -  sizeof(DWORD);

              //  
              //  allocate buffer  for  the new acl
              //  
             pNewAcl  =  (PACL)HeapAlloc(
                  GetProcessHeap() ,
                  HEAP_ZERO_MEMORY ,
                  dwNewAclSize
                  );
              if  (pNewAcl  ==  NULL)
                  __leave;

              //  
              //  initialize the new acl
              //  
              if  ( ! InitializeAcl(pNewAcl ,  dwNewAclSize ,  ACL_REVISION))
                  __leave;

              //  
              //   if  DACL is present ,  copy it to a new DACL
              //  
              if  (bDaclPresent)  //  only copy  if  DACL was present
                  {
                   //  copy the ACEs to  our  new ACL
                   if  (aclSizeInfo . AceCount)
                       {
                        for  (i = 0 ; i  <  aclSizeInfo . AceCount; i ++ )
                            {
                             //  get an ACE
                             if  ( ! GetAce(pacl ,  i ,   & pTempAce))
                                 __leave;

                             //  add the ACE to the new ACL
                             if  ( ! AddAce(
                                 pNewAcl ,
                                 ACL_REVISION ,
                                 MAXDWORD ,
                                 pTempAce ,
                                 ((PACE_HEADER)pTempAce) -> AceSize
                                 ))
                                 __leave;
                             }
                        }
                  }

              //  
              //  add ace to the dacl
              //  
              if  ( ! AddAccessAllowedAce(
                  pNewAcl ,
                  ACL_REVISION ,
                  DESKTOP_ALL ,
                  psid
                  ))
                  __leave;

              //  
              //  set new dacl to the new security descriptor
              //  
              if  ( ! SetSecurityDescriptorDacl(
                       psdNew ,
                       TRUE ,
                       pNewAcl ,
                       FALSE
                       ))
                  __leave;

              //  
              //  set the new security descriptor  for  the desktop object
              //  
              if  ( ! SetUserObjectSecurity(hdesk ,   & si ,  psdNew))
                  __leave;

              //  
              //  indicate success
              //  
             bSuccess  =  TRUE;
             }
        __finally
            {
             //  
             //  free buffers
             //  
             if  (pNewAcl  !=  NULL)
                 HeapFree(GetProcessHeap() ,   0 ,  (LPVOID)pNewAcl);

              if  (psd  !=  NULL)
                  HeapFree(GetProcessHeap() ,   0 ,  (LPVOID)psd);

              if  (psdNew  !=  NULL)
                  HeapFree(GetProcessHeap() ,   0 ,  (LPVOID)psdNew);
             }

         return  bSuccess;
   }





代码功能：让一个运行在SYSTEM权限下的进程与当前用户的桌面进行交互
代码：

程序代码 程序代码
#define  DESKTOP_ALL  ( DESKTOP_READOBJECTS  |  DESKTOP_CreateWINDOW  |  /
DESKTOP_CreateMENU  |  DESKTOP_HOOKCONTROL  |  DESKTOP_JOURNALRECORD  |  /
DESKTOP_JOURNALPLAYBACK  |  DESKTOP_ENUMERATE  |  DESKTOP_WRITEOBJECTS  |  /
DESKTOP_SWITCHDESKTOP  |  STANDARD_RIGHTS_REQUIRED )

#define WINSTA_ALL  ( WINSTA_ENUMDESKTOPS  |  WINSTA_READATTRIBUTES  |  /
WINSTA_ACCESSCLIPBOARD  |  WINSTA_CreateDESKTOP  |  WINSTA_WRITEATTRIBUTES  |  /
WINSTA_ACCESSGLOBALATOMS  |  WINSTA_EXITWINDOWS  |  WINSTA_ENUMERATE  |  /
WINSTA_READSCREEN  |  STANDARD_RIGHTS_REQUIRED )

#define GENERIC_ACCESS  ( GENERIC_READ  |  GENERIC_WRITE  |  GENERIC_EXECUTE  |  GENERIC_ALL )

BOOL AddAceToWindowStation ( HWINSTA hwinsta ,  PSID psid ) ;

BOOL AddAceToDesktop ( HDESK hdesk ,  PSID psid ) ;

BOOL GetLogonSID  ( HANDLE hToken ,  PSID  * ppsid ) ;

VOID FreeLogonSID  ( PSID  * ppsid ) ;

BOOL StartInteractiveClientProcess  (
    LPTSTR lpszUsername ,      // client to log on
    LPTSTR lpszDomain,      // domain of client's account
    LPTSTR lpszPassword,    // client's password
    LPTSTR lpCommandLine    // command line to execute
);


/*
int main()
{
    StartInteractiveClientProcess("test",NULL,"wrxzyl","C://Program Files//Internet Explorer//IEXPLORE.EXE http://www.zxboy.com ");
    return 0;
}
*/
BOOL StartInteractiveClientProcess (
    LPTSTR lpszUsername,    // client to log on
    LPTSTR lpszDomain,      // domain of client's account
    LPTSTR lpszPassword,    // client's password
    LPTSTR lpCommandLine    // command line to execute
) 
{
   HANDLE      hToken;
   HDESK       hdesk = NULL;
   HWINSTA     hwinsta = NULL, hwinstaSave = NULL;
   PROCESS_INFORMATION pi;
   PSID pSid = NULL;
   STARTUPINFO si;
   BOOL bResult = FALSE;

// Log the client on to the local computer.

   if (!LogonUser(
           lpszUsername,
           lpszDomain,
           lpszPassword,
           LOGON32_LOGON_INTERACTIVE,
           LOGON32_PROVIDER_DEFAULT,
           &hToken) ) 
   {
      goto Cleanup;
   }

// Save a handle to the caller's current window station.

   if ( (hwinstaSave = GetProcessWindowStation() ) == NULL)
      goto Cleanup;

// Get a handle to the interactive window station.

   hwinsta = OpenWindowStation(
       "winsta0",                   // the interactive window station 
       FALSE,                       // handle is not inheritable
       READ_CONTROL | WRITE_DAC);   // rights to read/write the DACL

   if (hwinsta == NULL) 
      goto Cleanup;

// To get the correct default desktop, set the caller's 
// window station to the interactive window station.

   if (!SetProcessWindowStation(hwinsta))
      goto Cleanup;

// Get a handle to the interactive desktop.

   hdesk = OpenDesktop(
      "default",     // the interactive window station 
      0,             // no interaction with other desktop processes
      FALSE,         // handle is not inheritable
      READ_CONTROL | // request the rights to read and write the DACL
      WRITE_DAC | 
      DESKTOP_WRITEOBJECTS | 
      DESKTOP_READOBJECTS);

// Restore the caller's window station.

   if (!SetProcessWindowStation(hwinstaSave)) 
      goto Cleanup;

   if (hdesk == NULL) 
      goto Cleanup;

// Get the SID for the client's logon session.

   if (!GetLogonSID(hToken, &pSid)) 
      goto Cleanup;

// Allow logon SID full access to interactive window station.

   if (! AddAceToWindowStation(hwinsta, pSid) ) 
      goto Cleanup;

// Allow logon SID full access to interactive desktop.

   if (! AddAceToDesktop(hdesk, pSid) ) 
      goto Cleanup;

// Impersonate client to ensure access to executable file.

   if (! ImpersonateLoggedOnUser(hToken) ) 
      goto Cleanup;

// Initialize the STARTUPINFO structure.
// Specify that the process runs in the interactive desktop.

   ZeroMemory(&si, sizeof(STARTUPINFO));
   si.cb= sizeof(STARTUPINFO);
   si.lpDesktop = TEXT("winsta0//default");

// Launch the process in the client's logon session.

   bResult = CreateProcessAsUser(
      hToken,            // client's access token
      NULL,              // file to execute
      lpCommandLine,     // command line
      NULL,              // pointer to process SECURITY_ATTRIBUTES
      NULL,              // pointer to thread SECURITY_ATTRIBUTES
      FALSE,             // handles are not inheritable
      NORMAL_PRIORITY_CLASS | Create_NEW_CONSOLE,   // creation flags
      NULL,              // pointer to new environment block 
      NULL,              // name of current directory 
      &si,               // pointer to STARTUPINFO structure
      π                // receives information about new process
   ); 

// End impersonation of client.
   //dwError=GetLastError();
   RevertToSelf();

   if (bResult && pi.hProcess != INVALID_HANDLE_VALUE) 
   { 
      WaitForSingleObject(pi.hProcess, INFINITE); 
      CloseHandle(pi.hProcess); 
   } 

   if (pi.hThread != INVALID_HANDLE_VALUE)
      CloseHandle(pi.hThread);  

Cleanup: 

   if (hwinstaSave != NULL)
      SetProcessWindowStation (hwinstaSave);

// Free the buffer for the logon SID.

   if (pSid)
      FreeLogonSID(&pSid);

// Close the handles to the interactive window station and desktop.

   if (hwinsta)
      CloseWindowStation(hwinsta);

   if (hdesk)
      CloseDesktop(hdesk);

// Close the handle to the client's access token.

   if (hToken != INVALID_HANDLE_VALUE)
      CloseHandle(hToken);  

   return bResult;
}

BOOL AddAceToWindowStation(HWINSTA hwinsta,PSID psid)
{
   ACCESS_ALLOWED_ACE   *pace;
   ACL_SIZE_INFORMATION aclSizeInfo;
   BOOL                 bDaclExist;
   BOOL                 bDaclPresent;
   BOOL                 bSuccess = FALSE;
   DWORD                dwNewAclSize;
   DWORD                dwSidSize = 0;
   DWORD                dwSdSizeNeeded;
   PACL                 pacl;
   PACL                 pNewAcl;
   PSECURITY_DESCRIPTOR psd = NULL;
   PSECURITY_DESCRIPTOR psdNew = NULL;
   PVOID                pTempAce;
   SECURITY_INFORMATION si = DACL_SECURITY_INFORMATION;
   unsigned int         i;

   __try
   {
      // Obtain the DACL for the window station.

      if (!GetUserObjectSecurity(
             hwinsta,
             &si,
             psd,
             dwSidSize,
             &dwSdSizeNeeded)
      )
      if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
      {
         psd = (PSECURITY_DESCRIPTOR)HeapAlloc(
               GetProcessHeap(),
               HEAP_ZERO_MEMORY,
               dwSdSizeNeeded);

         if (psd == NULL)
            __leave;

         psdNew = (PSECURITY_DESCRIPTOR)HeapAlloc(
               GetProcessHeap(),
               HEAP_ZERO_MEMORY,
               dwSdSizeNeeded);

         if (psdNew == NULL)
            __leave;

         dwSidSize = dwSdSizeNeeded;

         if (!GetUserObjectSecurity(
               hwinsta,
               &si,
               psd,
               dwSidSize,
               &dwSdSizeNeeded)
         )
            __leave;
      }
      else
         __leave;

      // Create a new DACL.

      if (!InitializeSecurityDescriptor(
            psdNew,
            SECURITY_DESCRIPTOR_REVISION)
      )
         __leave;

      // Get the DACL from the security descriptor.

      if (!GetSecurityDescriptorDacl(
            psd,
            &bDaclPresent,
            &pacl,
            &bDaclExist)
      )
         __leave;

      // Initialize the ACL.

      ZeroMemory(&aclSizeInfo, sizeof(ACL_SIZE_INFORMATION));
      aclSizeInfo.AclBytesInUse = sizeof(ACL);

      // Call only if the DACL is not NULL.

      if (pacl != NULL)
      {
         // get the file ACL size info
         if (!GetAclInformation(
               pacl,
               (LPVOID)&aclSizeInfo,
               sizeof(ACL_SIZE_INFORMATION),
               AclSizeInformation)
         )
            __leave;
      }

      // Compute the size of the new ACL.

      dwNewAclSize = aclSizeInfo.AclBytesInUse +
            (2*sizeof(ACCESS_ALLOWED_ACE)) + (2*GetLengthSid(psid)) -
            (2*sizeof(DWORD));

      // Allocate memory for the new ACL.

      pNewAcl = (PACL)HeapAlloc(
            GetProcessHeap(),
            HEAP_ZERO_MEMORY,
            dwNewAclSize);

      if (pNewAcl == NULL)
         __leave;

      // Initialize the new DACL.

      if (!InitializeAcl(pNewAcl, dwNewAclSize, ACL_REVISION))
         __leave;

      // If DACL is present, copy it to a new DACL.

      if (bDaclPresent)
      {
         // Copy the ACEs to the new ACL.
         if (aclSizeInfo.AceCount)
         {
            for (i=0; i < aclSizeInfo.AceCount; i++)
            {
               // Get an ACE.
               if (!GetAce(pacl, i, &pTempAce))
                  __leave;

               // Add the ACE to the new ACL.
               if (!AddAce(
                     pNewAcl,
                     ACL_REVISION,
                     MAXDWORD,
                     pTempAce,
                    ((PACE_HEADER)pTempAce)->AceSize)
               )
                  __leave;
            }
         }
      }

      // Add the first ACE to the window station.

      pace = (ACCESS_ALLOWED_ACE *)HeapAlloc(
            GetProcessHeap(),
            HEAP_ZERO_MEMORY,
            sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(psid) -
                  sizeof(DWORD));

      if (pace == NULL)
         __leave;

      pace->Header.AceType  = ACCESS_ALLOWED_ACE_TYPE;
      pace->Header.AceFlags = CONTAINER_INHERIT_ACE |
                   INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE;
      pace->Header.AceSize  = sizeof(ACCESS_ALLOWED_ACE) +
                   GetLengthSid(psid) - sizeof(DWORD);
      pace->Mask            = GENERIC_ACCESS;

      if (!CopySid(GetLengthSid(psid), &pace->SidStart, psid))
         __leave;

      if (!AddAce(
            pNewAcl,
            ACL_REVISION,
            MAXDWORD,
            (LPVOID)pace,
            pace->Header.AceSize)
      )
         __leave;

      // Add the second ACE to the window station.

      pace->Header.AceFlags = NO_PROPAGATE_INHERIT_ACE;
      pace->Mask            = WINSTA_ALL;

      if (!AddAce(
            pNewAcl,
            ACL_REVISION,
            MAXDWORD,
            (LPVOID)pace,
            pace->Header.AceSize)
      )
         __leave;

      // Set a new DACL for the security descriptor.

      if (!SetSecurityDescriptorDacl(
            psdNew,
            TRUE,
            pNewAcl,
            FALSE)
      )
         __leave;

      // Set the new security descriptor for the window station.

      if (!SetUserObjectSecurity(hwinsta, &si, psdNew))
         __leave;

      // Indicate success.

      bSuccess = TRUE;
   }
   __finally
   {
      // Free the allocated buffers.

      if (pace != NULL)
         HeapFree(GetProcessHeap(), 0, (LPVOID)pace);

      if (pNewAcl != NULL)
         HeapFree(GetProcessHeap(), 0, (LPVOID)pNewAcl);

      if (psd != NULL)
         HeapFree(GetProcessHeap(), 0, (LPVOID)psd);

      if (psdNew != NULL)
         HeapFree(GetProcessHeap(), 0, (LPVOID)psdNew);
   }

   return bSuccess;

}

BOOL AddAceToDesktop(HDESK hdesk, PSID psid)
{
   ACL_SIZE_INFORMATION aclSizeInfo;
   BOOL                 bDaclExist;
   BOOL                 bDaclPresent;
   BOOL                 bSuccess = FALSE;
   DWORD                dwNewAclSize;
   DWORD                dwSidSize = 0;
   DWORD                dwSdSizeNeeded;
   PACL                 pacl;
   PACL                 pNewAcl;
   PSECURITY_DESCRIPTOR psd = NULL;
   PSECURITY_DESCRIPTOR psdNew = NULL;
   PVOID                pTempAce;
   SECURITY_INFORMATION si = DACL_SECURITY_INFORMATION;
   unsigned int         i;

   __try
   {
      // Obtain the security descriptor for the desktop object.

      if (!GetUserObjectSecurity(
            hdesk,
            &si,
            psd,
            dwSidSize,
            &dwSdSizeNeeded))
      {
         if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
         {
            psd = (PSECURITY_DESCRIPTOR)HeapAlloc(
                  GetProcessHeap(),
                  HEAP_ZERO_MEMORY,
                  dwSdSizeNeeded );

            if (psd == NULL)
               __leave;

            psdNew = (PSECURITY_DESCRIPTOR)HeapAlloc(
                  GetProcessHeap(),
                  HEAP_ZERO_MEMORY,
                  dwSdSizeNeeded);

            if (psdNew == NULL)
               __leave;

            dwSidSize = dwSdSizeNeeded;

            if (!GetUserObjectSecurity(
                  hdesk,
                  &si,
                  psd,
                  dwSidSize,
                  &dwSdSizeNeeded)
            )
               __leave;
         }
         else
            __leave;
      }

      // Create a new security descriptor.

      if (!InitializeSecurityDescriptor(
            psdNew,
            SECURITY_DESCRIPTOR_REVISION)
      )
         __leave;

      // Obtain the DACL from the security descriptor.

      if (!GetSecurityDescriptorDacl(
            psd,
            &bDaclPresent,
            &pacl,
            &bDaclExist)
      )
         __leave;

      // Initialize.

      ZeroMemory(&aclSizeInfo, sizeof(ACL_SIZE_INFORMATION));
      aclSizeInfo.AclBytesInUse = sizeof(ACL);

      // Call only if NULL DACL.

      if (pacl != NULL)
      {
         // Determine the size of the ACL information.

         if (!GetAclInformation(
               pacl,
               (LPVOID)&aclSizeInfo,
               sizeof(ACL_SIZE_INFORMATION),
               AclSizeInformation)
         )
            __leave;
      }

      // Compute the size of the new ACL.

      dwNewAclSize = aclSizeInfo.AclBytesInUse +
            sizeof(ACCESS_ALLOWED_ACE) +
            GetLengthSid(psid) - sizeof(DWORD);

      // Allocate buffer for the new ACL.

      pNewAcl = (PACL)HeapAlloc(
            GetProcessHeap(),
            HEAP_ZERO_MEMORY,
            dwNewAclSize);

      if (pNewAcl == NULL)
         __leave;

      // Initialize the new ACL.

      if (!InitializeAcl(pNewAcl, dwNewAclSize, ACL_REVISION))
         __leave;

      // If DACL is present, copy it to a new DACL.

      if (bDaclPresent)
      {
         // Copy the ACEs to the new ACL.
         if (aclSizeInfo.AceCount)
         {
            for (i=0; i < aclSizeInfo.AceCount; i++)
            {
               // Get an ACE.
               if (!GetAce(pacl, i, &pTempAce))
                  __leave;

               // Add the ACE to the new ACL.
               if (!AddAce(
                  pNewAcl,
                  ACL_REVISION,
                  MAXDWORD,
                  pTempAce,
                  ((PACE_HEADER)pTempAce)->AceSize)
               )
                  __leave;
            }
         }
      }

      // Add ACE to the DACL.

      if (!AddAccessAllowedAce(
            pNewAcl,
            ACL_REVISION,
            DESKTOP_ALL,
            psid)
      )
         __leave;

      // Set new DACL to the new security descriptor.

      if (!SetSecurityDescriptorDacl(
            psdNew,
            TRUE,
            pNewAcl,
            FALSE)
      )
         __leave;

      // Set the new security descriptor for the desktop object.

      if (!SetUserObjectSecurity(hdesk, &si, psdNew))
         __leave;

      // Indicate success.

      bSuccess = TRUE;
   }
   __finally
   {
      // Free buffers.

      if (pNewAcl != NULL)
         HeapFree(GetProcessHeap(), 0, (LPVOID)pNewAcl);

      if (psd != NULL)
         HeapFree(GetProcessHeap(), 0, (LPVOID)psd);

      if (psdNew != NULL)
         HeapFree(GetProcessHeap(), 0, (LPVOID)psdNew);
   }

   return bSuccess;
}

BOOL GetLogonSID (HANDLE hToken, PSID *ppsid) 
{
   BOOL bSuccess = FALSE;
   DWORD dwIndex;
   DWORD dwLength = 0;
   PTOKEN_GROUPS ptg = NULL;

// Verify the parameter passed in is not NULL.
    if (NULL == ppsid)
        goto Cleanup;

// Get required buffer size and allocate the TOKEN_GROUPS buffer.

   if (!GetTokenInformation(
         hToken,         // handle to the access token
         TokenGroups,    // get information about the token's groups 
         (LPVOID) ptg,   // pointer to TOKEN_GROUPS buffer
         0,              // size of buffer
         &dwLength       // receives required buffer size
      )) 
   {
      if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) 
         goto Cleanup;

      ptg = (PTOKEN_GROUPS)HeapAlloc(GetProcessHeap(),
         HEAP_ZERO_MEMORY, dwLength);

      if (ptg == NULL)
         goto Cleanup;
   }

// Get the token group information from the access token.

   if (!GetTokenInformation(
         hToken,         // handle to the access token
         TokenGroups,    // get information about the token's groups 
         (LPVOID) ptg,   // pointer to TOKEN_GROUPS buffer
         dwLength,       // size of buffer
         &dwLength       // receives required buffer size
         )) 
   {
      goto Cleanup;
   }

// Loop through the groups to find the logon SID.

   for (dwIndex = 0; dwIndex < ptg->GroupCount; dwIndex++) 
      if ((ptg->Groups[dwIndex].Attributes & SE_GROUP_LOGON_ID)
             ==  SE_GROUP_LOGON_ID) 
      {
      // Found the logon SID; make a copy of it.

         dwLength = GetLengthSid(ptg->Groups[dwIndex].Sid);
         *ppsid = (PSID) HeapAlloc(GetProcessHeap(),
                     HEAP_ZERO_MEMORY, dwLength);
         if (*ppsid == NULL)
             goto Cleanup;
         if (!CopySid(dwLength, *ppsid, ptg->Groups[dwIndex].Sid)) 
         {
             HeapFree(GetProcessHeap(), 0, (LPVOID)*ppsid);
             goto Cleanup;
         }
         break;
      }

   bSuccess = TRUE;

Cleanup: 

// Free the buffer for the token groups.

   if (ptg != NULL)
      HeapFree(GetProcessHeap(), 0, (LPVOID)ptg);

   return bSuccess;
}


VOID FreeLogonSID (PSID *ppsid) 
{
    HeapFree(GetProcessHeap(), 0, (LPVOID)*ppsid);
}
qinlicang
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从windows服务中打开窗口进程
诗剑书生的专栏
11-09 7021
IVR地方业务中有一个DBA_BJLDNW工具要在服务器上运行着.一旦断开业务即中止.需要写一个守护程序监视它,一旦发现关闭了即重新启动.为了防止守护程序本身被用户关闭,所以我打算做一个windows服务在后台运行.每5分钟列举一个当前系统进程,如果没有发现DBA_BJLDNW.exe则重新启动.问题是windows服务不是窗口进程,在这个进程中调用ShellExecute打开的应用程序也是在后台
C# win7服务与桌面交互程序
11-23
还在为Win7的系统不能弹出应用程序而苦恼吗，用这个就搞定了，意思意思1分就行了。 在 Interop.cs 文件中 两个可直接调用的方法 1. ShowMessageBox 向用户桌面显示一个...2. CreateProcess 在用户的桌面开启一个进程
什么是桌面互动以及其特点
左昂投影互动
06-28 1998
桌面互动系统是属于互动投影的一种展现方式，通过投影仪投射到桌面上代替传统的图片、影像，效果更佳新颖、独特，参观者可以用手触摸桌面屏幕，进行互动，参观者可以更好的了解展示宣传的信息。 桌面互动投影采用多点触控技术，是允许用户通过多个手指来控制圆形界面的一种技术，与其他的互动投影所不同的是，桌面互动投影是在桌面上的投影方式，因此相对来说体积较小，但同样能够做出大面积的投影区域。除了查阅信息之外，桌面互动投影还有一项运用的比较广泛的区域，就是桌面互动投影游戏。在娱乐场所等领域运用的比较多，能够提高消费者的消费欲
windows核心编程笔记
xue_you的专栏
04-18 724
1.进程 进程通常被定义为一个正在运行的程序实例,他由2个部分组成: 一个是操作系统用来管理进程的内尔对象 一个是地址空间,他包含所有可执行模块或DLL模块的代码和数据.他还包括动态内存分配的空间.如线程堆栈和堆分配空间 进程是不活泼的。若要使进程完成某项操作，它必须拥有一个在它的环境中运行的线程，该线程负责执行包含在进程的地址空间中的代码。实际上， 单个进程可能包含若干个线程，所有这
易语言模拟CTRL+ALT+DELETE
07-21
易语言模拟CTRL+ALT+DELETE源码,模拟CTRL+ALT+DELETE,SendCAD,GetProcessWindowStation,GetThreadDesktop,GetCurrentThreadId,OpenWindowStationA,SetProcessWindowStation,OpenDesktop,SetThreadDesktop,PostMessage,CloseDesktop,CloseWindowStation
Win8下编译openssl成功 最后一步链接出问题的解决办法
u014598410的专栏
04-11 6641
nmake过程中，一断的缺少 .h .lib 等文件，不知道如何设置路径 直接复制
WinForm与Web的进程内交互
04-17
总结，通过VS2010的WinForm和WebBrowser控件，我们可以实现WinForm与Web的进程内交互，这为混合应用开发提供了便利。不过，在实际应用中，还需要注意安全性和性能优化，以确保应用程序的稳定性和用户体验。
axd.rar_进程与线程
09-20
标题中的"axd.rar_进程与线程"表明这是一个关于操作系统中进程和线程概念的压缩文件，可能包含一些源代码或文档，用于教学或分析。描述提到的应用程序具有类似于OICQ（现为QQ）的界面，允许用户管理和浏览文件夹及...
C# 解决Win7服务与桌面交互应用（服务启动后台应用程序）
05-09
1. **创建代理进程**：服务可以启动一个无界面的代理进程，该代理进程具有与桌面交互的权限。服务通过进程间通信（如命名管道、内存映射文件或WCF服务）与代理进程通信，指示代理进程启动具有用户界面的应用程序。 ...
VC9.rar_woolyy7_进程与线程
最新发布
09-24
《VC9.rar_woolyy7_进程与线程：深入理解进程线程及皮肤换装技术》...通过对压缩包内的文件分析，我们可以了解到软件开发中进程线程的运用，以及如何实现界面的个性化定制，这些都是现代桌面应用开发中不可或缺的技术。
rdmber.zip_进程与线程_Others_
08-09
描述提到"本程序可以在界面上输入电话号码后"，暗示这可能是一个处理电话号码的桌面应用程序，它可能涉及到用户界面交互以及后台处理任务。在这个背景下，进程和线程的概念就显得尤为重要，因为它们决定了程序如何...
98377004.rar_进程与线程_Delphi_
08-10
通过这个压缩包，开发者可以学习如何在Delphi中创建和管理进程，理解线程同步机制，如互斥量、信号量和事件，以及如何在多线程环境下处理窗体和用户交互。此外，还可以了解到如何调试和分析由Delphi编译的exe进程，...
6321772.rar_进程与线程_Others_
08-09
开发者可能通过阅读源代码学习如何在类似环境中集成和管理系统托盘功能，同时了解PPC系统下的进程和线程管理，尤其是与用户界面交互的部分。通过解压缩并编译这些文件，我们可以实际运行代码并查看其工作原理，...
jvin.rar_进程与线程_Delphi_
08-10
标题中的"jvin.rar_进程与线程_Delphi_"表明这是一个关于进程和线程管理的Delphi编程项目。在Windows操作系统中，进程是程序执行的实例，而线程则是进程内的执行单元，允许程序同时执行多个任务。Delphi是一款强大的...
WinService.rar_进程与线程_C++_
08-11
6. **服务的交互**：默认情况下，服务不与桌面交互，但可以通过设置服务的属性使其能够显示UI元素。然而，这通常不是推荐的做法，因为服务应尽可能地保持独立和无界面。 在C++中，通常使用`LPCSTR`类型表示字符串，...
Virtual Desktop: A Simple Desktop Management Tool
lionzl的专栏
03-21 622
Virtual Desktop: A Simple Desktop Management Tool 时间: 2009.01.08 20:07:00 标签:   Download demo project - 260.89 KB Download source - 44.5 KB IntroductionA few months ago, one of my
搞个Windows服务程序
weixin_34096182的博客
11-23 141
windows服务程序方便，可以自动启动，也不受登录用户影响。没有界面，不大方便，但也有好处，眼不见心不烦。说说它怎么安装：1、添加一个项：安装程序类2、在这个安装程序页面上添加两个组件ServiceInstaller,ServiceProcessInstaller，并设置3、编译好的exe要用InstallUtil.exe来进行安装。installUtil.exe为windows自带，搜一下...
小熊鼠标键盘模拟工具 使用说明 及核心代码
足球中国的专栏
01-11 2482
旧版本有些问题，请下载新版本 最版版本一载地址 很多人问的问题是怎么模拟向QQ群发送信息的  其实标题就说了是模拟鼠标，按键。 具体哪些按键呢，可能有些人习惯鼠标操作不太清楚，其实也很简单。enter键 next键。配合鼠标使用就可以了。 其实就是这么简单了。 核心代码: using Microsoft.VisualBasic; using System; using Sys

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值