VC++中程序提升管理员权限的两种方法

2024年1月29日 224次阅读 来源: 高傲的三师兄

程序的权限不够，应用管理员权限打开程序运行方可。

如何使vc程序运行时请求管理员权限？

如果是2005或者2008 就简单了，直接

(项目右键—属性—连接器—清单文件—uac执行级别 选择requireAdministrator )中文版

(project->property->Configuration Properties->Linker->Manifest File->UAC  Execution Level 选择requireAdministrator)英文版

重新编译 这样你的程序直接运行就拥有管理员权限了。 

代码提权


   
   
 
    
    
  
  1.       /****************************************************************  
    2. 
    
  
  2.       本类功能：提升本程序进程优先级和权限  
    3. 
    
  
  3.       编写作者：Coderui  
    4. 
    
  
  4.       编写日期：2008年03月24日  
    5. 
    
  
  5.       联系邮箱：coderui@163.com   
    6. 
    
  
  6.       作者博客：http://hi.baidu.com/coderui   
    7. 
    
  
  7.       文件名称：EnablePriv.h  
    8. 
    
  
  8.       ****************************************************************/  
    9. 
    
  
  9.        
    10. 
    
  
  10.       class CEnablePriv  
    11. 
    
  
  11.       {  
    12. 
    
  
  12.       public: //公有(对外开放的接口)  
    13. 
    
  
  13.        
    14. 
    
  
  14.       //  
    15. 
    
  
  15.       //设置当前进程优先级为最高(实时)  
    16. 
    
  
  16.       //  
    17. 
    
  
  17.       BOOL SetRealTimePriority();  
    18. 
    
  
  18.        
    19. 
    
  
  19.       //  
    20. 
    
  
  20.       //提升当前进程权限函数(“SeShutdownPrivilege”关机权限)  
    21. 
    
  
  21.       //  
    22. 
    
  
  22.       BOOL EnableShutdownPriv();  
    23. 
    
  
  23.        
    24. 
    
  
  24.       //  
    25. 
    
  
  25.       //提升当前进程权限函数(“SeDebugPrivilege”读、写控制权限)  
    26. 
    
  
  26.       //  
    27. 
    
  
  27.       BOOL EnableDebugPriv();  
    28. 
    
  
  28.        
    29. 
    
  
  29.       //  
    30. 
    
  
  30.       //提升当前进程权限函数(“SeBackupPrivilege”注册表备份权限)  
    31. 
    
  
  31.       //  
    32. 
    
  
  32.       BOOL EnableBackupPriv();  
    33. 
    
  
  33.        
    34. 
    
  
  34.       //  
    35. 
    
  
  35.       //提升当前进程权限函数(“SeRestorePrivilege”恢复数据权限)  
    36. 
    
  
  36.       //  
    37. 
    
  
  37.       BOOL EnableRestorePriv();  
    38. 
    
  
  38.        
    39. 
    
  
  39.       private: //私有(内部使用的接口)  
    40. 
    
  
  40.        
    41. 
    
  
  41.       };  
    42. 
    
  
  42.       ——————————————————————————————————————————  
    43. 
    
  
  43.       /****************************************************************  
    44. 
    
  
  44.       本类功能：提升本程序进程优先级和权限  
    45. 
    
  
  45.       编写作者：Coderui  
    46. 
    
  
  46.       编写日期：2008年03月24日  
    47. 
    
  
  47.       联系邮箱：coderui@163.com   
    48. 
    
  
  48.       作者博客：http://hi.baidu.com/coderui   
    49. 
    
  
  49.       文件名称：EnablePriv.cpp  
    50. 
    
  
  50.       ****************************************************************/  
    51. 
    
  
  51.        
    52. 
    
  
  52.       #include “stdafx.h” //需要引用MFC中的这个头文件  
    53. 
    
  
  53.       #include “EnablePriv.h” //调用时需要引用的联接头文件  
    54. 
    
  
  54.        
    55. 
    
  
  55.       //宏的功能介绍:  
    56. 
    
  
  56.       //————————————————————-  
    57. 
    
  
  57.       //#define SE_BACKUP_NAME TEXT(“SeBackupPrivilege”) //备份数据权限  
    58. 
    
  
  58.       //#define SE_RESTORE_NAME TEXT(“SeRestorePrivilege”) //恢复数据权限  
    59. 
    
  
  59.       //#define SE_SHUTDOWN_NAME TEXT(“SeShutdownPrivilege”) //关机权限  
    60. 
    
  
  60.       //#define SE_DEBUG_NAME TEXT(“SeDebugPrivilege”) //读、写控制权限  
    61. 
    
  
  61.       //————————————————————-  
    62. 
    
  
  62.        
    63. 
    
  
  63.       //宏的功能介绍:  
    64. 
    
  
  64.       //————————————————————-  
    65. 
    
  
  65.       //ABOVE_NORMAL_PRIORITY_CLASS(0x00008000) 高于标准  
    66. 
    
  
  66.       //BELOW_NORMAL_PRIORITY_CLASS(0x00004000) 低于标准  
    67. 
    
  
  67.       //HIGH_PRIORITY_CLASS(0x00000080) 高  
    68. 
    
  
  68.       //IDLE_PRIORITY_CLASS(0x00000040) 低  
    69. 
    
  
  69.       //NORMAL_PRIORITY_CLASS(0x00000020) 标准  
    70. 
    
  
  70.       //REALTIME_PRIORITY_CLASS(0x00000100) 实时  
    71. 
    
  
  71.       //————————————————————-  
    72. 
    
  
  72.        
    73. 
    
  
  73.       //  
    74. 
    
  
  74.       //设置当前进程优先级为最高(实时)  
    75. 
    
  
  75.       //  
    76. 
    
  
  76.       //返回值：“false”是失败，“true”是成功。  
    77. 
    
  
  77.       BOOL CEnablePriv::SetRealTimePriority()  
    78. 
    
  
  78.       {  
    79. 
    
  
  79.       if( ! SetPriorityClass( GetCurrentProcess(), REALTIME_PRIORITY_CLASS ))  
    80. 
    
  
  80.       {  
    81. 
    
  
  81.       return false;  
    82. 
    
  
  82.       }  
    83. 
    
  
  83.        
    84. 
    
  
  84.       return true;  
    85. 
    
  
  85.       }  
    86. 
    
  
  86.        
    87. 
    
  
  87.       //  
    88. 
    
  
  88.       //提升当前进程权限函数(“SeShutdownPrivilege”关机权限)  
    89. 
    
  
  89.       //  
    90. 
    
  
  90.       //返回值：“false”是失败，“true”是成功。  
    91. 
    
  
  91.       BOOL CEnablePriv::EnableShutdownPriv()  
    92. 
    
  
  92.       {  
    93. 
    
  
  93.       HANDLE hToken;  
    94. 
    
  
  94.       LUID sedebugnameValue;  
    95. 
    
  
  95.       TOKEN_PRIVILEGES tkp;  
    96. 
    
  
  96.        
    97. 
    
  
  97.       if ( ! OpenProcessToken( GetCurrentProcess(),  
    98. 
    
  
  98.       TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken ) )  
    99. 
    
  
  99.       return false;  
    100. 
    
  
  100.        
    101. 
    
  
  101.       if ( ! LookupPrivilegeValue( NULL, SE_SHUTDOWN_NAME, &sedebugnameValue ) )  
    102. 
    
  
  102.       {  
    103. 
    
  
  103.       CloseHandle( hToken );  
    104. 
    
  
  104.       return false;  
    105. 
    
  
  105.       }  
    106. 
    
  
  106.        
    107. 
    
  
  107.       tkp.PrivilegeCount = 1;  
    108. 
    
  
  108.       tkp.Privileges[ 0].Luid = sedebugnameValue;  
    109. 
    
  
  109.       tkp.Privileges[ 0].Attributes = SE_PRIVILEGE_ENABLED;  
    110. 
    
  
  110.        
    111. 
    
  
  111.       if ( ! AdjustTokenPrivileges( hToken, FALSE, &tkp, sizeof tkp, NULL, NULL ) )  
    112. 
    
  
  112.       CloseHandle( hToken );  
    113. 
    
  
  113.        
    114. 
    
  
  114.       return true;  
    115. 
    
  
  115.       }  
    116. 
    
  
  116.        
    117. 
    
  
  117.       //  
    118. 
    
  
  118.       //提升当前进程权限函数(“SeDebugPrivilege”读、写控制权限)  
    119. 
    
  
  119.       //  
    120. 
    
  
  120.       //返回值：“false”是失败，“true”是成功。  
    121. 
    
  
  121.       BOOL CEnablePriv::EnableDebugPriv()  
    122. 
    
  
  122.       {  
    123. 
    
  
  123.       HANDLE hToken;  
    124. 
    
  
  124.       LUID sedebugnameValue;  
    125. 
    
  
  125.       TOKEN_PRIVILEGES tkp;  
    126. 
    
  
  126.        
    127. 
    
  
  127.       if ( ! OpenProcessToken( GetCurrentProcess(),  
    128. 
    
  
  128.       TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken ) )  
    129. 
    
  
  129.       return false;  
    130. 
    
  
  130.        
    131. 
    
  
  131.       if ( ! LookupPrivilegeValue( NULL, SE_DEBUG_NAME, &sedebugnameValue ) )  
    132. 
    
  
  132.       {  
    133. 
    
  
  133.       CloseHandle( hToken );  
    134. 
    
  
  134.       return false;  
    135. 
    
  
  135.       }  
    136. 
    
  
  136.        
    137. 
    
  
  137.       tkp.PrivilegeCount = 1;  
    138. 
    
  
  138.       tkp.Privileges[ 0].Luid = sedebugnameValue;  
    139. 
    
  
  139.       tkp.Privileges[ 0].Attributes = SE_PRIVILEGE_ENABLED;  
    140. 
    
  
  140.        
    141. 
    
  
  141.       if ( ! AdjustTokenPrivileges( hToken, FALSE, &tkp, sizeof tkp, NULL, NULL ) )  
    142. 
    
  
  142.       CloseHandle( hToken );  
    143. 
    
  
  143.        
    144. 
    
  
  144.       return true;  
    145. 
    
  
  145.       }  
    146. 
    
  
  146.        
    147. 
    
  
  147.       //  
    148. 
    
  
  148.       //提升当前进程权限函数(“SeBackupPrivilege”备份数据权限)  
    149. 
    
  
  149.       //  
    150. 
    
  
  150.       //返回值：“false”是失败，“true”是成功。  
    151. 
    
  
  151.       BOOL CEnablePriv::EnableBackupPriv()  
    152. 
    
  
  152.       {  
    153. 
    
  
  153.       HANDLE hToken;  
    154. 
    
  
  154.       LUID sedebugnameValue;  
    155. 
    
  
  155.       TOKEN_PRIVILEGES tkp;  
    156. 
    
  
  156.        
    157. 
    
  
  157.       if ( ! OpenProcessToken( GetCurrentProcess(),  
    158. 
    
  
  158.       TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken ) )  
    159. 
    
  
  159.       return false;  
    160. 
    
  
  160.        
    161. 
    
  
  161.       if ( ! LookupPrivilegeValue( NULL, SE_BACKUP_NAME, &sedebugnameValue ) )  
    162. 
    
  
  162.       {  
    163. 
    
  
  163.       CloseHandle( hToken );  
    164. 
    
  
  164.       return false;  
    165. 
    
  
  165.       }  
    166. 
    
  
  166.        
    167. 
    
  
  167.       tkp.PrivilegeCount = 1;  
    168. 
    
  
  168.       tkp.Privileges[ 0].Luid = sedebugnameValue;  
    169. 
    
  
  169.       tkp.Privileges[ 0].Attributes = SE_PRIVILEGE_ENABLED;  
    170. 
    
  
  170.        
    171. 
    
  
  171.       if ( ! AdjustTokenPrivileges( hToken, FALSE, &tkp, sizeof tkp, NULL, NULL ) )  
    172. 
    
  
  172.       CloseHandle( hToken );  
    173. 
    
  
  173.        
    174. 
    
  
  174.       return true;  
    175. 
    
  
  175.       }  
    176. 
    
  
  176.        
    177. 
    
  
  177.       //  
    178. 
    
  
  178.       //提升当前进程权限函数(“SeRestorePrivilege”恢复数据权限)  
    179. 
    
  
  179.       //  
    180. 
    
  
  180.       //返回值：“false”是失败，“true”是成功。  
    181. 
    
  
  181.       BOOL CEnablePriv::EnableRestorePriv()  
    182. 
    
  
  182.       {  
    183. 
    
  
  183.       HANDLE hToken;  
    184. 
    
  
  184.       LUID sedebugnameValue;  
    185. 
    
  
  185.       TOKEN_PRIVILEGES tkp;  
    186. 
    
  
  186.        
    187. 
    
  
  187.       if ( ! OpenProcessToken( GetCurrentProcess(),  
    188. 
    
  
  188.       TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken ) )  
    189. 
    
  
  189.       return false;  
    190. 
    
  
  190.        
    191. 
    
  
  191.       if ( ! LookupPrivilegeValue( NULL, SE_RESTORE_NAME, &sedebugnameValue ) )  
    192. 
    
  
  192.       {  
    193. 
    
  
  193.       CloseHandle( hToken );  
    194. 
    
  
  194.       return false;  
    195. 
    
  
  195.       }  
    196. 
    
  
  196.        
    197. 
    
  
  197.       tkp.PrivilegeCount = 1;  
    198. 
    
  
  198.       tkp.Privileges[ 0].Luid = sedebugnameValue;  
    199. 
    
  
  199.       tkp.Privileges[ 0].Attributes = SE_PRIVILEGE_ENABLED;  
    200. 
    
  
  200.        
    201. 
    
  
  201.       if ( ! AdjustTokenPrivileges( hToken, FALSE, &tkp, sizeof tkp, NULL, NULL ) )  
    202. 
    
  
  202.       CloseHandle( hToken );  
    203. 
    
  
  203.        
    204. 
    
  
  204.       return true;  
    205. 
    
  
  205.       }  
    206. 
   
 

   
   

            </div>
    原文作者：高傲的三师兄
    原文地址: https://blog.csdn.net/xunying6967/article/details/82656963
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞