From 2f26648d48ae7098d5c553c91676e8b88ccc7b68 Mon Sep 17 00:00:00 2001 From: cora32 Date: Tue, 14 Apr 2015 14:58:33 +0300 Subject: [PATCH] Main starter refactoring, import-rescan bug fixed. --- MainStarter.cpp | 1320 +++++++++++++++++++++++++++ MainStarter.h | 130 +++ NescaLogicStarter.cpp | 5 - NescaLogicStarter.h | 75 -- STh.cpp | 16 +- STh.h | 9 +- Threader.cpp | 2 - externData.h | 4 +- externFunctions.h | 3 - mainResources.h | 2 +- nesca_3.cpp | 83 +- nesca_3.h | 2 +- nesca_startModule.cpp | 2005 +---------------------------------------- progressbardrawer.cpp | 2 +- version | 2 +- 15 files changed, 1521 insertions(+), 2139 deletions(-) create mode 100644 MainStarter.cpp create mode 100644 MainStarter.h delete mode 100644 NescaLogicStarter.cpp delete mode 100644 NescaLogicStarter.h diff --git a/MainStarter.cpp b/MainStarter.cpp new file mode 100644 index 0000000..415da91 --- /dev/null +++ b/MainStarter.cpp @@ -0,0 +1,1320 @@ +#include "STh.h" +#include "MainStarter.h" +#include "Connector.h" +#include + +std::vector MainStarter::portVector; +int MainStarter::flCounter = 0; + +QJsonArray *jsonArr = new QJsonArray(); + +bool horLineFlag = false; +bool gShuffle = true; + +int ipCounter = 0; + +long long unsigned gTargets = 0, gTargetsNumber = 1; + +char currentMask[128] = { 0 }; +char metaRange[256] = { 0 }; +char metaPercent[256] = { 0 }; +char metaIPS[256] = { 0 }; +char metaTargets[256] = { 0 }; +char metaETA[256] = { 0 }; +char metaOffline[256] = { 0 }; + +std::vector splitToStringVector(const std::string &s, char delim) { + std::vector elems; + std::stringstream ss(s); + std::string item; + + while (std::getline(ss, item, delim)) { + elems.push_back(item); + } + + return elems; +} +std::vector splitToIntVector(const std::string &s, char delim) { + std::vector elems; + std::stringstream ss(s); + std::string item; + + while (std::getline(ss, item, delim)) { + elems.push_back(std::stoi(item)); + } + + return elems; +} +void MainStarter::fileLoader(const char *fileName) { + + char curIP[256] = { 0 }, curIPCopy[256] = { 0 }; + unsigned int importFileSize = 0; + + FILE *fl = fopen(fileName, "r"); + if (fl != NULL) + { + while (fgets((char*)curIP, sizeof(curIP), fl) != NULL) + { + if (curIP[0] != '#' && curIP[0] != ' ' && curIP[0] != '\n' && curIP[0] != '\r' && strcmp(curIP, "") != 0 && + ((curIP[0] == '/' && curIP[1] == '/') == false) && ((curIP[0] == '\t' && curIP[1] == '\t' && curIP[2] == '\t' && (curIP[3] == 13 || curIP[3] == 10 || curIP[3] == '#')) == false) + && (curIP[0] == '\t' && curIP[1] == '\t' && curIP[2] == '\t' && (curIP[3] == '/' && curIP[4] == '/')) == false) + { + ++importFileSize; + }; + ZeroMemory(curIP, sizeof(curIP)); + }; + + ipsstartfl = new unsigned int*[importFileSize + 2]; + ipsendfl = new unsigned int*[importFileSize + 2]; + + ZeroMemory(ipsstartfl, importFileSize); + ZeroMemory(ipsendfl, importFileSize); + + for (int i = 0; i < importFileSize; ++i) + { + ipsstartfl[i] = new unsigned int[4]; + ipsendfl[i] = new unsigned int[4]; + + ZeroMemory(ipsstartfl[i], 4); + ZeroMemory(ipsendfl[i], 4); + }; + + rewind(fl); + + while (fgets(curIP, 256, fl) != NULL) + { + if (curIP[0] != '#' && curIP[0] != ' ' && curIP[0] != '\n' && curIP[0] != '\r' && strcmp(curIP, "") != 0 && + ((curIP[0] == '/' && curIP[1] == '/') == false) && ((curIP[0] == '\t' && curIP[1] == '\t' && curIP[2] == '\t' && (curIP[3] == 13 || curIP[3] == 10 || curIP[3] == '#')) == false) + && (curIP[0] == '\t' && curIP[1] == '\t' && curIP[2] == '\t' && (curIP[3] == '/' && curIP[4] == '/')) == false) + { + strcpy(curIPCopy, curIP); + char *ptr1 = strstr(curIP, " "); + if (ptr1 != NULL) curIP[(int)(ptr1 - curIP)] = '\0'; + ptr1 = strstr(curIP, " "); + if (ptr1 != NULL) curIP[(int)(ptr1 - curIP) - 1] = '\0'; + ptr1 = strstr(curIP, "#"); + if (ptr1 != NULL) curIP[(int)(ptr1 - curIP) - 1] = '\0'; + if (strcmp(curIP, "") == 0 || strcmp(curIP, " ") == 0 || strcmp(curIP, "\r\n") == 0 || strcmp(curIP, "\n") == 0 || curIP[0] == ' ' || curIP[0] == '#') + { + ZeroMemory(curIPCopy, sizeof(curIPCopy)); + ZeroMemory(curIP, sizeof(curIP)); + continue; + }; + + if (strstr(curIP, "-") != NULL) + { + bool firstPart = true; + int offset = 0; + int curNIndex = 0; + char curS; + char curN[32] = { 0 }; + for (int i = 0; i < strlen(curIP); ++i) + { + curS = curIP[i]; + if (curS == '.') + { + if (firstPart) ipsstartfl[MainStarter::flCounter][offset] = atoi(curN); + else ipsendfl[MainStarter::flCounter][offset] = atoi(curN); + ++offset; + curNIndex = 0; + ZeroMemory(curN, 32); + continue; + } + else if (curS == '-') + { + if (firstPart) ipsstartfl[MainStarter::flCounter][offset] = atoi(curN); + else ipsendfl[MainStarter::flCounter][offset] = atoi(curN); + offset = 0; + firstPart = false; + curNIndex = 0; + ZeroMemory(curN, 32); + continue; + }; + curN[curNIndex++] = curS; + if (i == strlen(curIP) - 1) + { + ipsendfl[MainStarter::flCounter][offset] = atoi(curN); + }; + }; + + if (ipsstartfl[MainStarter::flCounter][0] > ipsendfl[MainStarter::flCounter][0] + || (ipsstartfl[MainStarter::flCounter][0] >= ipsendfl[MainStarter::flCounter][0] + && ipsstartfl[MainStarter::flCounter][1] > ipsendfl[MainStarter::flCounter][1] + ) + || (ipsstartfl[MainStarter::flCounter][0] >= ipsendfl[MainStarter::flCounter][0] + && ipsstartfl[MainStarter::flCounter][1] >= ipsendfl[MainStarter::flCounter][1] + && ipsstartfl[MainStarter::flCounter][2] > ipsendfl[MainStarter::flCounter][2] + ) + || (ipsstartfl[MainStarter::flCounter][0] >= ipsendfl[MainStarter::flCounter][0] + && ipsstartfl[MainStarter::flCounter][1] >= ipsendfl[MainStarter::flCounter][1] + && ipsstartfl[MainStarter::flCounter][2] >= ipsendfl[MainStarter::flCounter][2] + && ipsstartfl[MainStarter::flCounter][3] > ipsendfl[MainStarter::flCounter][3] + ) + ) + { + char tempMsg[256] = { 0 }; + strcpy(tempMsg, "[IP Loader]Wrong list format. Line-> ["); + strcat(tempMsg, std::to_string(MainStarter::flCounter).c_str()); + strcat(tempMsg, "] String-> ["); + strcat(tempMsg, curIPCopy); + strcat(tempMsg, "]"); + stt->doEmitionRedFoundData(QString(tempMsg)); + return; + }; + + gTargets += 256 * 256 * 256 * (ipsendfl[MainStarter::flCounter][0] - ipsstartfl[MainStarter::flCounter][0]); + gTargets += 256 * 256 * (ipsendfl[MainStarter::flCounter][1] - ipsstartfl[MainStarter::flCounter][1]); + gTargets += 256 * (ipsendfl[MainStarter::flCounter][2] - ipsstartfl[MainStarter::flCounter][2]); + gTargets += (ipsendfl[MainStarter::flCounter][3] - ipsstartfl[MainStarter::flCounter][3]); + ++MainStarter::flCounter; + } + else if (strstr(curIP, "/") != NULL) + { + unsigned int ip[4] = { 0 }, ip_min[4] = { 0 }, ip_max[4] = { 0 }, tmp1, tmp2; + unsigned int netmask = atoi(strstr(curIP, "/") + 1); + char ip_string[19]; + + std::vector tmpIPVec = splitToIntVector(curIP, '.'); + + for (int i = 0; i < tmpIPVec.size(); ++i) ip[i] = tmpIPVec[i]; + + /*Set the bytes which won't be changed*/ + for (tmp1 = tmp2 = netmask / 8; tmp1>0; tmp1--){ + ip_min[tmp1 - 1] = ip[tmp1 - 1]; + ip_max[tmp1 - 1] = ip[tmp1 - 1]; + } + /*Set the bytes which should be 0ed or 255ed.*/ + for (tmp1 = tmp2, ++tmp2; tmp2< 4; tmp2++){ + ip_min[tmp2] = 0; + ip_max[tmp2] = 255; + } + /* Finally set the one which has to be shifted.*/ + if (tmp1 < 4){ + tmp2 = 8 - netmask % 8; + ip_min[tmp1] = ip[tmp1] >> tmp2; + ip_min[tmp1] <<= tmp2; + ip_max[tmp1] = ip_min[tmp1] + pow(2, tmp2) - 1; + } + + ipsstartfl[MainStarter::flCounter][0] = ip_min[0]; + ipsstartfl[MainStarter::flCounter][1] = ip_min[1]; + ipsstartfl[MainStarter::flCounter][2] = ip_min[2]; + ipsstartfl[MainStarter::flCounter][3] = ip_min[3]; + + ipsendfl[MainStarter::flCounter][0] = ip_max[0]; + ipsendfl[MainStarter::flCounter][1] = ip_max[1]; + ipsendfl[MainStarter::flCounter][2] = ip_max[2]; + ipsendfl[MainStarter::flCounter][3] = ip_max[3]; + + unsigned long ip1 = (ip_min[0] * 16777216) + + (ip_min[1] * 65536) + + (ip_min[2] * 256) + + ip_min[3]; + unsigned long ip2 = (ip_max[0] * 16777216) + + (ip_max[1] * 65536) + + (ip_max[2] * 256) + + ip_max[3]; + gTargets += ip2 - ip1 + 1; + ++MainStarter::flCounter; + } + else if (strstr(curIP, "RESTORE_IMPORT_SESSION") != NULL) + { + ///DUMMY/// + } + else + { + char tempMsg[256] = { 0 }; + strcpy(tempMsg, "[IP Loader]Wrong list format. Line-> ["); + strcat(tempMsg, std::to_string(MainStarter::flCounter).c_str()); + strcat(tempMsg, "] String-> ["); + strcat(tempMsg, curIPCopy); + strcat(tempMsg, "]"); + stt->doEmitionRedFoundData("[IP Loader]Wrong list format. Line-> [" + + QString::number(MainStarter::flCounter) + + "] String-> [" + + QString(curIPCopy) + + "]"); + return; + }; + ZeroMemory(curIP, sizeof(curIP)); + }; + }; + gTargetsNumber = gTargets; + + stt->doEmitionYellowFoundData("List loader - [OK] (" + QString::number(gTargetsNumber + 1) + " hosts)"); + fclose(fl); + } + else + { + stt->doEmitionRedFoundData("[IP Loader] Cannot open IP list."); + }; +} +int MainStarter::loadTargets(const char *data) { + + if (gMode == 0) { + std::vector rangeVec; + + if (strstr(data, "/") != NULL) { + + unsigned int ip[4] = { 0 }, ip_min[4] = { 0 }, ip_max[4] = { 0 }, tmp1, tmp2; + unsigned int netmask = atoi(strstr(data, "/") + 1); + char ip_string[19]; + + std::vector tmpIPVec = splitToIntVector(data, '.'); + + for (int i = 0; i < tmpIPVec.size(); ++i) ip[i] = tmpIPVec[i]; + + /*Set the bytes which won't be changed*/ + for (tmp1 = tmp2 = netmask / 8; tmp1>0; tmp1--){ + ip_min[tmp1 - 1] = ip[tmp1 - 1]; + ip_max[tmp1 - 1] = ip[tmp1 - 1]; + } + /*Set the bytes which should be 0ed or 255ed.*/ + for (tmp1 = tmp2, ++tmp2; tmp2< 4; tmp2++){ + ip_min[tmp2] = 0; + ip_max[tmp2] = 255; + } + /* Finally set the one which has to be shifted.*/ + if (tmp1 < 4){ + tmp2 = 8 - netmask % 8; + ip_min[tmp1] = ip[tmp1] >> tmp2; + ip_min[tmp1] <<= tmp2; + ip_max[tmp1] = ip_min[tmp1] + pow(2, tmp2) - 1; + } + + char newRangeString[128] = { 0 }; + sprintf(newRangeString, "%u.%u.%u.%u-%u.%u.%u.%u", + ip_min[0], ip_min[1], ip_min[2], ip_min[3], ip_max[0], ip_max[1], ip_max[2], ip_max[3]); + rangeVec = splitToStringVector(std::string(newRangeString), '-'); + } + else rangeVec = splitToStringVector(data, '-'); + + std::vector ip1TmpVec = splitToIntVector(rangeVec[0], '.'); + std::vector ip2TmpVec = splitToIntVector(rangeVec[1], '.'); + + ipsstart[0] = ip1TmpVec[0]; + ipsstart[1] = ip1TmpVec[1]; + ipsstart[2] = ip1TmpVec[2]; + ipsstart[3] = ip1TmpVec[3]; + + ipsend[0] = ip2TmpVec[0]; + ipsend[1] = ip2TmpVec[1]; + ipsend[2] = ip2TmpVec[2]; + ipsend[3] = ip2TmpVec[3]; + + ip1 = (ipsstart[0] * 16777216) + + (ipsstart[1] * 65536) + + (ipsstart[2] * 256) + + ipsstart[3]; + ip2 = (ipsend[0] * 16777216) + + (ipsend[1] * 65536) + + (ipsend[2] * 256) + + ipsend[3]; + sprintf(finalIP, "%d.%d.%d.%d", + ipsend[0], ipsend[1], ipsend[2], ipsend[3]); + } + else if (gMode == 1) { + strncpy(dnsTarget, data, 256); + } + else { + fileLoader(data); + + ip1 = (ipsstartfl[gflIndex][0] * 16777216) + + (ipsstartfl[gflIndex][1] * 65536) + + (ipsstartfl[gflIndex][2] * 256) + + ipsstartfl[gflIndex][3]; + ip2 = (ipsendfl[gflIndex][0] * 16777216) + + (ipsendfl[gflIndex][1] * 65536) + + (ipsendfl[gflIndex][2] * 256) + + ipsendfl[gflIndex][3]; + sprintf(finalIP, "%d.%d.%d.%d", + ipsendfl[0], ipsendfl[1], ipsendfl[2], ipsendfl[3]); + } + + if (ip1 > ip2) { + stt->doEmitionRedFoundData("Malformed input: check your range"); + return -1; + } + + gTargets = ip2 - ip1 + 1; + gTargetsNumber = gTargets; + + return 0; +} +int MainStarter::loadPorts(const char *data, char delim) { + portVector = splitToIntVector(data, delim); + for (auto elem : portVector) { + if (elem > 65535 | elem < 0) { + stt->doEmitionRedFoundData("Malformed input: check your ports"); + return -1; + } + } + return 0; +} + +void MainStarter::saveBackupToFile() +{ + char saveStr[512] = { 0 }; + char saveBuffer[4096] = { 0 }; + char endStr[128] = { 0 }; + + if (gMode == 0 || gMode == 1) + { + if (gMode == 1) + { + if (strlen(currentMask) == 0) { + sprintf(endStr, "%s", currentIP); + } + else strcpy(endStr, currentMask); + } + else + { + if (strlen(finalIP) == 0) sprintf(endStr, "%s", currentIP); + else sprintf(endStr, "%s-%s", currentIP, finalIP); + }; + + if (strlen(endStr) > 0) + { + sprintf(saveStr, "[SESSION]:%d %s %s %d %s\n", + gMode, endStr, gTLD, gThreads, gPorts); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + }; + } + else if (gMode == -1) + { + char ipRange[128] = { 0 }; + + if (MainStarter::flCounter > 0) + { + FILE *savingFile = fopen("tempIPLst.bk", "w"); + if (savingFile != NULL) + { + sprintf(ipRange, "%s-%d.%d.%d.%d\n", + currentIP, + ipsendfl[gflIndex][0], + ipsendfl[gflIndex][1], + ipsendfl[gflIndex][2], + ipsendfl[gflIndex][3]); + fputs(ipRange, savingFile); + + ZeroMemory(ipRange, sizeof(ipRange)); + for (int tCounter = gflIndex + 1; tCounter < MainStarter::flCounter; ++tCounter) + { + sprintf(ipRange, "%d.%d.%d.%d-%d.%d.%d.%d\n", + ipsstartfl[tCounter][0], + ipsstartfl[tCounter][1], + ipsstartfl[tCounter][2], + ipsstartfl[tCounter][3], + ipsendfl[tCounter][0], + ipsendfl[tCounter][1], + ipsendfl[tCounter][2], + ipsendfl[tCounter][3]); + + fputs(ipRange, savingFile); + + ZeroMemory(ipRange, sizeof(ipRange)); + }; + fclose(savingFile); + } + else stt->doEmitionRedFoundData("[_saver] Cannot open file."); + }; + + sprintf(saveStr, "[SESSION]:%d RESTORE_IMPORT_SESSION %d %s\n", gMode, gThreads, gPorts); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + }; + + sprintf(saveStr, "[NDBSERVER]:%s\n", trcSrv); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[NDBSCRIPT]:%s\n", trcScr); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[NDBPORT]:%s\n", trcSrvPortLine); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[PROXY]:%s\n", trcProxy); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[PROXYPORT]:%s\n", trcPort); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[PING]:%s\n", gPingNScan ? "true" : "false"); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[SHUFFLE]:%s\n", gShuffle ? "true" : "false"); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[NSTRACK]:%s\n", trackerOK ? "true" : "false"); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[PING_TO]: %d\n", gPingTimeout); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[THREAD_DELAY]: %d\n", gThreadDelay); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[TIMEOUT]: %d\n", gTimeOut); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[MAXBTHR]: %d\n", gMaxBrutingThreads); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[SYSTEMPROXYIP]: %s\n", gProxyIP); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + sprintf(saveStr, "[SYSTEMPROXYPORT]: %s\n", gProxyPort); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + strcpy(saveStr, "[PERSKEY]:"); + strncat(saveStr, trcPersKey, 32); + strcat(saveStr, "\n"); + strcat(saveBuffer, saveStr); + ZeroMemory(saveStr, sizeof(saveStr)); + + FILE *savingFile = fopen("restore", "w"); + + if (savingFile != NULL) + { + fputs(saveBuffer, savingFile); + fclose(savingFile); + } + else stt->doEmitionRedFoundData("[_saver] Cannot open file."); + + ZeroMemory(saveStr, strlen(saveStr)); + ZeroMemory(saveBuffer, strlen(saveBuffer)); +} + +bool saverRunning = false; +void MainStarter::saver() +{ + saverRunning = true; + Sleep(1000); + while (globalScanFlag) + { + __savingBackUpFile = true; + saveBackupToFile(); + __savingBackUpFile = false; + Sleep(10000); + }; + saverRunning = false; +} + +bool ipPerSecTimer = false; +void _IPPerSecTimer() { + ipPerSecTimer = true; + int ticks = 0; + int ovrlIPs = 0; + Sleep(50); + + while (globalScanFlag) + { + ovrlIPs += ipCounter; + ipCounter = 0; + + sprintf(metaIPS, "%f.5", ovrlIPs / ++ticks); + + Sleep(1000); + } + ipPerSecTimer = false; +} + +bool trackerRunning = false; +void _tracker() { + trackerRunning = true; + while (true) { + while (globalScanFlag && !trackerOK) Sleep(1000); + + if (!globalScanFlag && jsonArr->size() == 0) break; + char rBuffT[250000] = { 0 }; + char *msg = new char[4096]; + ZeroMemory(msg, sizeof(*msg)); + char ndbServer[64] = { 0 }; + char ndbScriptT[64] = { 0 }; + char ndbScript[64] = { 0 }; + + sockaddr_in sockAddr; + sockAddr.sin_family = AF_INET; + sockAddr.sin_port = htons(atoi(trcSrvPortLine)); + + sprintf(msg, "GET /%s HTTP/1.1\r\nHost: %s\r\nX-Nescav3: True\r\nContent-Type: application/x-www-form-urlencoded\r\nConnection: close\r\n\r\n", + trcScr, trcSrv); + + HOSTENT *host; + +#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__) + 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); + + if (connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)) == -1) + { + CSSOCKET(sock); + + stt->doEmitionRedFoundData("[NS-Track] -Cannot connect to balancer! " + QString::number(WSAGetLastError()) + "."); + + continue; + }; + + if (send(sock, msg, strlen(msg), 0) == -1) + { + CSSOCKET(sock); + + stt->doEmitionRedFoundData("[NS-Track] -Cannot send to balancer! " + QString::number(WSAGetLastError()) + "."); + + continue; + }; + + ZeroMemory(rBuffT, sizeof(rBuffT)); + char rBuff[512] = { 0 }; + int test = recv(sock, rBuff, sizeof(rBuff), 0); + strcpy(rBuffT, rBuff); + + while ((test = recv(sock, rBuff, sizeof(rBuff), 0)) != 0) + { + if (strlen(rBuffT) > 200000) + { + stt->doEmitionRedFoundData("[NS-Track] (Outer) -Large error received from server (>200000b) " + + QString::number(WSAGetLastError()) + "."); + break; + }; + strcat(rBuffT, rBuff); + }; + + if (test == -1) + { + CSSOCKET(sock); + + stt->doEmitionRedFoundData("[NS-Track] -Cannot recv from balancer! " + QString::number(WSAGetLastError()) + "."); + + continue; + }; + + char *t1; + char *t2; + if (strstr(rBuffT, "http://") != NULL) + { + t1 = strstr(rBuffT, "http://"); + if (strstr((char*)(t1 + 7), "/") != NULL) + { + t2 = strstr((char*)(t1 + 7), "/"); + int ln = t2 - t1 - 7; + if (ln > 64) + { + CSSOCKET(sock); + + stt->doEmitionRedFoundData("[NS-Track] -Received server string is not valid!"); + + continue; + } + else strncpy(ndbServer, (char*)(t1 + 7), ln); + + if (strlen(t2) > 64) + { + + stt->doEmitionYellowFoundData("[NS-Track] -Fragmentation detected!"); + + if (strstr(t2, "\r\n") != NULL) + { + char *t3 = strstr(t2, "\r\n"); + int y = (int)(t3 - t2); + + if (y > 64) + { + CSSOCKET(sock); + + stt->doEmitionRedFoundData("[NS-Track] -Received server string is not valid!"); + + continue; + } + else + { + strncpy(ndbScriptT, t2, y); + CSSOCKET(sock); + + stt->doEmitionGreenFoundData("[NS-Track] -OK! -Fragmented server string aquired! Starting NS-Track loop..."); + + strncpy(ndbScript, ndbScriptT, strlen(ndbScriptT)); + }; + } + else + { + CSSOCKET(sock); + + stt->doEmitionRedFoundData("[NS-Track] -Received server string is not valid!"); + + continue; + }; + } + else + { + strcpy(ndbScriptT, t2); + + stt->doEmitionGreenFoundData("[NS-Track] -OK! -Server string aquired! Starting NS-Track loop..."); + + CSSOCKET(sock); + strncpy(ndbScript, ndbScriptT, strlen(ndbScriptT) - 2); + }; + } + else + { + CSSOCKET(sock); + + stt->doEmitionRedFoundData("[NS-Track] -Cannot receive script value!"); + + continue; + }; + + ZeroMemory(rBuffT, sizeof(rBuffT)); + CSSOCKET(sock); + + while (true) + { + if (!globalScanFlag && jsonArr->size() == 0) break; + if (!trackerOK) { + Sleep(1000); + continue; + }; + + if (jsonArr->size() > 0) + { + QJsonObject jsonKey; + if (jsonArr == NULL) jsonArr = new QJsonArray(); + + QJsonObject jsonMeta; + if (gMode == 0) jsonMeta.insert("mode", QJsonValue(QString("IP"))); // + else if (gMode == 1) jsonMeta.insert("mode", QJsonValue(QString("DNS"))); //Mode + else if (gMode == -1) jsonMeta.insert("mode", QJsonValue(QString("Import"))); // + jsonMeta.insert("range", QJsonValue(QString(metaRange))); + jsonMeta.insert("current", QJsonValue(QString(currentIP))); + if (gMode == 1) jsonMeta.insert("tld", QJsonValue(QString(gTLD))); //TLD + jsonMeta.insert("targets", QJsonValue(QString(metaTargets))); + jsonMeta.insert("percent", QJsonValue(QString(metaPercent))); + jsonMeta.insert("saved", QJsonValue(QString::number(saved))); + jsonMeta.insert("found", QJsonValue(QString::number(found))); + jsonMeta.insert("speed", QJsonValue(QString(metaIPS))); + jsonMeta.insert("eta", QJsonValue(QString(metaETA))); + jsonMeta.insert("threads", QJsonValue(QString::number(cons) + "/" + QString::number(gThreads))); + jsonMeta.insert("bads", QJsonValue(QString::number(offlines))); + jsonMeta.insert("version", QJsonValue(QString(gVER))); + + jsonArr->push_front(QJsonValue(jsonMeta)); + memset(trcPersKey + 32, '\0', 1); + jsonKey.insert("key", QJsonValue(QString(trcPersKey))); + jsonArr->push_front(jsonKey); + + QJsonDocument js; + js.setArray(*jsonArr); + QByteArray r = js.toJson(); + + sockAddr.sin_family = AF_INET; + sockAddr.sin_port = htons(atoi(trcSrvPortLine)); + + if (msg != NULL) + { + delete[]msg; + msg = 0; + }; + + msg = new char[r.size() + 1024]; + ZeroMemory(msg, sizeof(*msg)); + + strcpy(msg, "POST /"); + strcat(msg, ndbScript); + strcat(msg, " HTTP/1.1\r\nHost: "); + strcat(msg, ndbServer); + strcat(msg, "\r\nContent-Type: application/json\r\nAccept-Encoding: application/json\r\nContent-Length: "); + strcat(msg, std::to_string(r.size()).c_str()); + strcat(msg, "\r\nConnection: close\r\n\r\n"); + + strcat(msg, r.data()); + + delete jsonArr; + jsonArr = new QJsonArray(); + +#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__) + 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); + + if (gDebugMode) + { + stt->doEmitionDebugFoundData("Connecting to " + QString(ndbServer)); + }; + + if (connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)) == -1) + { + CSSOCKET(sock); + + + stt->doEmitionRedFoundData("[NS-Track] -connect() returned " + QString::number(WSAGetLastError()) + "."); + + continue; + }; + + if (gDebugMode) + { + stt->doEmitionDebugFoundData("Sending!"); + stt->doEmitionDebugFoundData("Key: [" + QString(trcPersKey) + "]"); + stt->doEmitionDebugFoundData("MSG: [" + QString(msg) + "]"); + }; + + if (send(sock, msg, strlen(msg), 0) == -1) + { + CSSOCKET(sock); + + stt->doEmitionRedFoundData("[NS-Track] -send() returned " + QString::number(WSAGetLastError()) + "."); + + continue; + }; + + ZeroMemory(rBuffT, sizeof(rBuffT)); + char msgR[32] = { 0 }; + + if (gDebugMode) + { + stt->doEmitionDebugFoundData("Receiving..."); + }; + + test = recv(sock, rBuff, 512, 0); + + if (gDebugMode) + { + stt->doEmitionDebugFoundData("Received: " + QString(rBuff)); + }; + + strncpy(msgR, rBuff, 32); + strcpy(rBuffT, rBuff); + while (test > 0) + { + if (test <= 0) break; + + if (strlen(rBuffT) > 200000) + { + stt->doEmitionRedFoundData("[NS-Track] (Inner) -Large error received from server (>200000b) " + + QString::number(WSAGetLastError()) + "."); + break; + }; + strcat(rBuffT, rBuff); + test = recv(sock, rBuff, 512, 0); + if (gDebugMode) + { + stt->doEmitionDebugFoundData("Received: " + QString(rBuff)); + }; + }; + + if (test == -1) + { + CSSOCKET(sock); + + stt->doEmitionRedFoundData("[NS-Track] -recv() returned " + QString::number(WSAGetLastError()) + "."); + + continue; + }; + + if (strstr(rBuffT, "201 Created") != NULL) + { + + if (gDebugMode) stt->doEmitionYellowFoundData("[NS-Track] -OK. Data saved!"); + stt->doEmitionDataSaved(true); + Sleep(1000); + stt->doEmitionDataSaved(false); + + } + else if (strstr(rBuffT, "400 Bad Request") != NULL) + { + + QString errorDef = GetNSErrorDefinition(rBuffT, "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 : " + errorDef + "]"); + + } + else + { + stt->doEmitionYellowFoundData("[NS-Track] -FAIL! An error occured [" + QString(msgR) + "]"); + }; + + ZeroMemory(msgR, sizeof(msgR)); + ZeroMemory(rBuffT, sizeof(rBuffT)); + ZeroMemory(msg, sizeof(*msg)); + + if (msg != NULL) + { + delete msg; + msg = NULL; + }; + + CSSOCKET(sock); + }; + Sleep(10000); + }; + } + else + { + stt->doEmitionRedFoundData("[NS-Track] -Balancer replied with invalid string."); + }; + + CSSOCKET(sock); + } + + trackerRunning = false; +} + +void verboseProgress(unsigned long target) { + + stt->doEmitionUpdateArc(gTargets); + if (gTargets > 0) --gTargets; + + char targetNPers[128] = { 0 }; + float percent = (gTargetsNumber != 0 ? (100 - target / (double)gTargetsNumber * 100) : 0); + + sprintf(targetNPers, "%Lu (%.1f%%)", target, percent); + + sprintf(metaTargets, "%Lu", target); + sprintf(metaPercent, "%.1f", + percent); +} + +void _connect() { + + std::string ip = ""; + std::unique_lock lk; + while (globalScanFlag) { + lk = std::unique_lock(Threader::m); + Threader::cv.wait(lk, []{return Threader::ready; }); + + if (!globalScanFlag || Threader::threadId > gThreads) { + --Threader::threadId; + lk.unlock(); + Threader::ready = true; + Threader::cv.notify_all(); + return; + } + + Threader::ready = false; + + if (!Threader::ipQueue.empty()) { + ip = Threader::ipQueue.front(); + Threader::ipQueue.pop(); + lk.unlock(); + + ++ipCounter; + + ++cons; + for (int i = 0; i < MainStarter::portVector.size(); ++i) + { + if (!globalScanFlag) break; + if (Connector::_ConnectToPort((char*)ip.c_str(), MainStarter::portVector[i]) == -2) break; + }; + --cons; + stt->doEmitionUpdateArc(gTargets); + } + else lk.unlock(); + } +} + +void MainStarter::startIPScan(){ + + switch (gShuffle) { + case true: { + std::vector ipVec; + struct in_addr tAddr; + + for (unsigned long i = ip1; i <= ip2; ++i) { + + if (!globalScanFlag) break; + unsigned long offset = ip2 - i; + + tAddr.s_addr = ntohl(i); + ipVec.push_back(inet_ntoa(tAddr)); + + if (ipVec.size() >= (offset < 1000 ? offset : 1000)) { + + std::random_shuffle(ipVec.begin(), ipVec.end()); + while (ipVec.size() != 0) { + + while (cons >= gThreads && globalScanFlag) Sleep(500); + if (!globalScanFlag) goto haters_gonna_hate_IPM; + + ++indexIP; + strcpy(currentIP, ipVec[0].c_str()); + ipVec.erase(ipVec.begin()); + + verboseProgress(gTargets); + + Threader::fireThread(currentIP, (void*(*)(void))_connect); + } + } + } + + haters_gonna_hate_IPM:; + break; + } + case false: { + struct in_addr tAddr; + for (unsigned long i = ip1; i <= ip2; ++i) { + + while (cons >= gThreads && globalScanFlag) Sleep(500); + if (!globalScanFlag) break; + + ++indexIP; + + tAddr.s_addr = ntohl(i); + strcpy(currentIP, inet_ntoa(tAddr)); + verboseProgress(gTargets); + + Threader::fireThread(currentIP, (void*(*)(void))_connect); + } + break; + } + } +} + +char charAll[38] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '_', '-', +'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', +'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' }; +int _getPos(char l) { + for (int i = 0; i < 38; ++i) + { + if (l == charAll[i]) return i; + }; + return -1; +} +int _GetDNSFromMask(char *mask, char *saveMask, char *saveMaskEnder) { + + if (strstr(mask, "[") != NULL) + { + char maskEnd[1024] = { 0 }; + char maskRes[1024] = { 0 }; + char *ptr1 = strstr(mask, "["); + char *ptr2 = strstr(ptr1, "]"); + int sz = ptr2 - ptr1; + char chunk[8] = { 0 }; + strncpy(chunk, ptr1, sz + 1); + int firstPos = _getPos(chunk[1]); + int secondPos = _getPos(chunk[2]); + + if (firstPos > secondPos) + { + stt->doEmitionRedFoundData("Error at mask (Wrong letter sequence)"); + return -1; + }; + + char maskStart[1024] = { 0 }; + int startPosition = strstr(mask, "[") - mask; + strncpy(maskStart, mask, startPosition); + + char maskEntry[1024] = { 0 }; + if (saveMaskEnder != NULL) + { + int startSavePosition = strstr(saveMaskEnder, "[") - saveMaskEnder; + strncpy(maskEntry, saveMaskEnder, startSavePosition); + }; + + int szMask = strlen(mask); + int szOffset = startPosition + 2; + if (szMask != szOffset) strcpy(maskEnd, strstr(mask, "]") + 1); + else ZeroMemory(maskEnd, sizeof(maskEnd));; + + char maskSaver[128] = { 0 }; + if (firstPos != -1 && secondPos != -1) + { + for (int i = firstPos; i <= secondPos; ++i) + { + if (!globalScanFlag) break; + + strcpy(maskSaver, saveMask); + strcat(maskSaver, maskEntry); + chunk[1] = charAll[i]; + strcat(maskSaver, chunk); + strcpy(maskRes, maskStart); + maskRes[startPosition] = charAll[i]; + strcat(maskRes, maskEnd); + + if (_GetDNSFromMask(maskRes, maskSaver, maskEnd) == -1) return -1; + + ZeroMemory(maskSaver, sizeof(maskSaver)); + ZeroMemory(maskRes, sizeof(maskRes)); + }; + }; + } + else + { + strcpy(currentMask, saveMask); + while (cons >= gThreads && globalScanFlag) Sleep(300); + if (!globalScanFlag) return 0; + + ++indexIP; + sprintf(currentIP, "%s%s", mask, gTLD); + verboseProgress(gTargets); + + Threader::fireThread(currentIP, (void*(*)(void))_connect); + }; +} +int _getChunkCount(char *data) { + int firstPos = _getPos(data[1]); + int secondPos = _getPos(data[2]); + return secondPos - firstPos + 1; +} +void MainStarter::startDNSScan(){ + char dataEntry[1024] = { 0 }; + int innerCounter = 0; + int sz = strlen(dnsTarget); + + for (int i = 0; i < sz; ++i) + { + if (dnsTarget[i] == '\\') + { + if (dnsTarget[i + 1] == 'd') + { + strcat(dataEntry, "[09]"); + ++i; + innerCounter += 4; + continue; + } + else if (dnsTarget[i + 1] == 'w') + { + strcat(dataEntry, "[0z]"); + ++i; + innerCounter += 4; + continue; + } + else if (dnsTarget[i + 1] == 'l') + { + strcat(dataEntry, "[az]"); + ++i; + innerCounter += 4; + continue; + } + else + { + QString errStr = "Error at mask (Position:" + QString::number(i + 1); + errStr += ") \""; + errStr += QString(dnsTarget).mid(0, i == 0 ? 0 : i); + errStr += ""; + errStr += QString(dnsTarget).mid(i, i == 0 ? i + 2 : i + 1); + errStr += ""; + errStr += QString(dnsTarget).mid(i + 2, strlen(dnsTarget)); + errStr += "\""; + + stt->doEmitionRedFoundData(errStr); + return; + }; + } + else + { + memset(dataEntry + innerCounter++, dnsTarget[i], 1); + }; + }; + + memset(dataEntry + innerCounter + 1, '\0', 1); + strcpy(currentMask, dataEntry); + + for (int i = 0; i < sz; ++i) + { + if (dataEntry[i] == '[') + { + for (int j = i + 1; j < i + 3; ++j) + { + if ((dataEntry[j] < '0' || dataEntry[j] > '9') + && (dataEntry[j] < 'a' || dataEntry[j] > 'z') + && dataEntry[j] != '_' + && dataEntry[j] != '-' + ) + { + QString errStr = "Error at mask (" + QString::number(j - 1); + errStr += ") \""; + errStr += QString(dataEntry).mid(0, j - 1); + errStr += ""; + errStr += QString(dataEntry).mid(j - 1, j + 1); + errStr += ""; + errStr += QString(dataEntry).mid(j + 1, strlen(dataEntry)); + errStr += "\""; + + stt->doEmitionRedFoundData(errStr); + return; + }; + }; + i += 3; + } + else if (dataEntry[i] == ']') + { + QString errStr = "Error at mask (" + QString::number(i - 1); + errStr += ") \""; + errStr += QString(dataEntry).mid(0, i - 1); + errStr += ""; + errStr += QString(dataEntry).mid(i - 1, i + 1); + errStr += ""; + errStr += QString(dataEntry).mid(i + 1, strlen(dataEntry)); + errStr += "\""; + + stt->doEmitionRedFoundData(errStr); + return; + }; + }; + + unsigned long long dnsCounter = 1; + char *dnsPtr1 = strstr(dataEntry, "["); + while (dnsPtr1 != NULL) + { + dnsCounter *= _getChunkCount(dnsPtr1); + dnsPtr1 = strstr(dnsPtr1 + 1, "["); + }; + + gTargets = dnsCounter; + gTargetsNumber = gTargets; + stt->doEmitionYellowFoundData("Starting DNS-scan..."); + stt->doEmitionChangeStatus("Scanning..."); + + int y = _GetDNSFromMask(dataEntry, "", dataEntry); + if (y == -1) + { + stt->doEmitionRedFoundData("DNS-Mode error"); + }; +} + +void MainStarter::startImportScan(){ + if (MainStarter::flCounter == 0) + { + stt->doEmitionRedFoundData("Empty IP list."); + globalScanFlag = false; + stt->doEmitionKillSttThread(); + return; + }; + + stt->doEmitionChangeStatus("Scanning..."); + for (gflIndex = 0; gflIndex < MainStarter::flCounter; ++gflIndex) + { + strcpy(metaRange, std::to_string(ipsstartfl[gflIndex][0]).c_str()); + strcat(metaRange, "."); + strcat(metaRange, std::to_string(ipsstartfl[gflIndex][1]).c_str()); + strcat(metaRange, "."); + strcat(metaRange, std::to_string(ipsstartfl[gflIndex][2]).c_str()); + strcat(metaRange, "."); + strcat(metaRange, std::to_string(ipsstartfl[gflIndex][3]).c_str()); + strcat(metaRange, "-"); + strcat(metaRange, std::to_string(ipsendfl[gflIndex][0]).c_str()); + strcat(metaRange, "."); + strcat(metaRange, std::to_string(ipsendfl[gflIndex][1]).c_str()); + strcat(metaRange, "."); + strcat(metaRange, std::to_string(ipsendfl[gflIndex][2]).c_str()); + strcat(metaRange, "."); + strcat(metaRange, std::to_string(ipsendfl[gflIndex][3]).c_str()); + + switch (gShuffle) { + case true: { + std::vector ipVec; + struct in_addr tAddr; + + for (unsigned long i = ip1; i <= ip2; ++i) { + + if (!globalScanFlag) break; + unsigned long offset = ip2 - i; + + tAddr.s_addr = ntohl(i); + ipVec.push_back(inet_ntoa(tAddr)); + + if (ipVec.size() >= (offset < 1000 ? offset : 1000)) { + + std::random_shuffle(ipVec.begin(), ipVec.end()); + while (ipVec.size() != 0) { + + while (cons >= gThreads && globalScanFlag) Sleep(500); + if (!globalScanFlag) goto haters_gonna_hate_IM; + + ++indexIP; + strcpy(currentIP, ipVec[0].c_str()); + ipVec.erase(ipVec.begin()); + verboseProgress(gTargets); + + Threader::fireThread(currentIP, (void*(*)(void))_connect); + } + } + } + haters_gonna_hate_IM:; + break; + } + case false: { + struct in_addr tAddr; + for (unsigned long i = ip1; i <= ip2; ++i) { + + while (cons >= gThreads && globalScanFlag) Sleep(500); + if (!globalScanFlag) break; + + ++indexIP; + + tAddr.s_addr = ntohl(i); + strcpy(currentIP, inet_ntoa(tAddr)); + verboseProgress(gTargets); + Threader::fireThread(currentIP, (void*(*)(void))_connect); + } + break; + }; + } + } +} + +void MainStarter::runAuxiliaryThreads() { + + FileUpdater::loadOnce(); + if (!FileUpdater::running) { + std::thread lpThread(FileUpdater::updateLists); + lpThread.detach(); + } + if (!trackerRunning) { + std::thread trackerThread(_tracker); + trackerThread.detach(); + } + if (!ipPerSecTimer) { + std::thread timerThread(_IPPerSecTimer); + timerThread.detach(); + } + if (!saverRunning) { + std::thread saverThread(&MainStarter::saver, this); + saverThread.detach(); + } +} + +void MainStarter::start() { + globalScanFlag = true; + runAuxiliaryThreads(); + + if (gMode == 0) startIPScan(); + else if (gMode == 1) startDNSScan(); + else startImportScan(); + + stt->doEmitionYellowFoundData("Stopping threads..."); + stt->doEmitionChangeStatus("Stopping..."); + + while (cons > 0 || jsonArr->size() > 0) { + Sleep(2000); + }; + + stt->doEmitionGreenFoundData("Done. Saved " + QString::number(saved) + + " of " + QString::number(found) + " nodes."); + stt->doEmitionChangeStatus("Idle"); + stt->doEmitionKillSttThread(); +} \ No newline at end of file diff --git a/MainStarter.h b/MainStarter.h new file mode 100644 index 0000000..2191646 --- /dev/null +++ b/MainStarter.h @@ -0,0 +1,130 @@ +#ifndef MAINSTARTER_H +#define MAINSTARTER_H + +#include +#include "externData.h" +#include "mainResources.h" +#include "Threader.h" +#include "FileUpdater.h" + +class MainStarter { +private: char dnsTarget[256]; + int ipsstart[4], ipsend[4]; + unsigned int **ipsstartfl = NULL, **ipsendfl = NULL; + unsigned long ip1, ip2; + int gflIndex = 0; + +private: + void startIPScan(); + void startDNSScan(); + void startImportScan(); + int loadPorts(const char *data, char delim); + int loadTargets(const char *data); + +public: + static std::vector portVector; + static int flCounter; + +public: + MainStarter(short mode, + const char* targets, + const char* ports, + const char* tld = nullptr + ) + { + horLineFlag = false; + PieAnomC1 = 0, PieWF = 0, PieBA = 0, PieSusp = 0, PieLowl = 0, PieSSH = 0; + AnomC1 = 0, baCount = 0, Filt = 0, Overl = 0, Lowl = 0, Alive = 0, Activity = 0, saved = 0, Susp = 0, + WF = 0, offlines = 0; + BrutingThrds = 0; + found = 0; + gTargets = 0; + cons = 0; + found = 0; + indexIP = 0; + flCounter = 0; + gflIndex = 0; + + ZeroMemory(ipsstart, sizeof(ipsstart)); + ZeroMemory(ipsend, sizeof(ipsend)); + + if (loadTargets(targets) == -1 || + loadPorts(ports, ',') == -1) return; + + curl_global_init(CURL_GLOBAL_ALL); + +#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__) + CreateDirectoryA(RESULT_DIR_NAME, NULL); +#else + struct stat str = { 0 }; + if (stat(RESULT_DIR_NAME, &str) == -1) { + mkdir(RESULT_DIR_NAME, 0700); + } +#endif + + } + ~MainStarter(){ + FileUpdater::FUClear(); + Threader::cleanUp(); + curl_global_cleanup(); + + while (__savingBackUpFile) Sleep(100); + + if (loginLst != NULL) + { + for (int i = 0; i < MaxLogin; ++i) delete[]loginLst[i]; + delete[]loginLst; + loginLst = NULL; + }; + if (passLst != NULL) + { + for (int i = 0; i < MaxPass; ++i) delete[]passLst[i]; + delete[]passLst; + passLst = NULL; + }; + if (GlobalNegatives != NULL) + { + for (int i = 0; i < GlobalNegativeSize; ++i) delete[]GlobalNegatives[i]; + delete[]GlobalNegatives; + GlobalNegatives = NULL; + }; + if (wfPassLst != NULL) + { + for (int i = 0; i < MaxWFPass; ++i) delete[]wfPassLst[i]; + delete[]wfPassLst; + wfPassLst = NULL; + }; + if (wfLoginLst != NULL) + { + for (int i = 0; i < MaxWFLogin; ++i) delete[]wfLoginLst[i]; + delete[]wfLoginLst; + wfLoginLst = NULL; + }; + if (sshlpLst != NULL) + { + for (int i = 0; i < MaxSSHPass; ++i) delete[]sshlpLst[i]; + delete[]sshlpLst; + sshlpLst = NULL; + }; + if (ipsstartfl != NULL) + { + for (int i = 0; i < flCounter; ++i) delete[]ipsstartfl[i]; + delete[]ipsstartfl; + ipsstartfl = NULL; + }; + if (ipsendfl != NULL) + { + for (int i = 0; i < flCounter; ++i) delete[]ipsendfl[i]; + delete[]ipsendfl; + ipsendfl = NULL; + }; + } + + void runAuxiliaryThreads(); + void saver(); + void saveBackupToFile(); + void fileLoader(const char *fileName); + void start(); +}; + +#endif // MAINSTARTER_H \ No newline at end of file diff --git a/NescaLogicStarter.cpp b/NescaLogicStarter.cpp deleted file mode 100644 index aa5d670..0000000 --- a/NescaLogicStarter.cpp +++ /dev/null @@ -1,5 +0,0 @@ -#include "NescaLogicStarter.h" - -int NLC::startScan(const char* args){ - return 1; -} \ No newline at end of file diff --git a/NescaLogicStarter.h b/NescaLogicStarter.h deleted file mode 100644 index e2909e0..0000000 --- a/NescaLogicStarter.h +++ /dev/null @@ -1,75 +0,0 @@ -#ifndef NESCALOGICSTARTER_H -#define NESCALOGICSTARTER_H - -class NLC { -public: - NLC(){ - - } - ~NLC(){ - /*FileUpdater::FUClear(); - Threader::cleanUp(); - curl_global_cleanup(); - - while (__savingBackUpFile) Sleep(100); - - if (loginLst != NULL) - { - for (int i = 0; i < MaxLogin; ++i) delete[]loginLst[i]; - delete[]loginLst; - loginLst = NULL; - }; - if (passLst != NULL) - { - for (int i = 0; i < MaxPass; ++i) delete[]passLst[i]; - delete[]passLst; - passLst = NULL; - }; - if (GlobalNegatives != NULL) - { - for (int i = 0; i < GlobalNegativeSize; ++i) delete[]GlobalNegatives[i]; - delete[]GlobalNegatives; - GlobalNegatives = NULL; - }; - if (wfPassLst != NULL) - { - for (int i = 0; i < MaxWFPass; ++i) delete[]wfPassLst[i]; - delete[]wfPassLst; - wfPassLst = NULL; - }; - if (wfLoginLst != NULL) - { - for (int i = 0; i < MaxWFLogin; ++i) delete[]wfLoginLst[i]; - delete[]wfLoginLst; - wfLoginLst = NULL; - }; - if (sshlpLst != NULL) - { - for (int i = 0; i < MaxSSHPass; ++i) delete[]sshlpLst[i]; - delete[]sshlpLst; - sshlpLst = NULL; - }; - if (ipsstartfl != NULL) - { - for (int i = 0; i < flCounter; ++i) delete[]ipsstartfl[i]; - delete[]ipsstartfl; - ipsstartfl = NULL; - }; - if (ipsendfl != NULL) - { - for (int i = 0; i < flCounter; ++i) delete[]ipsendfl[i]; - delete[]ipsendfl; - ipsendfl = NULL; - }; - if (starterIP != NULL) - { - for (int i = 0; i < flCounter; ++i) delete[]starterIP[i]; - delete[]starterIP; - starterIP = NULL; - };*/ - } - int startScan(const char* args); - -}; - -#endif // NESCALOGICSTARTER_H \ No newline at end of file diff --git a/STh.cpp b/STh.cpp index e664604..914ddbf 100644 --- a/STh.cpp +++ b/STh.cpp @@ -1,4 +1,5 @@ #include "STh.h" +#include "externData.h" void STh::doEmitionShowRedVersion() { @@ -73,7 +74,20 @@ void STh::doEmitionUpdateArc(unsigned long gTargets) emit stt->signalUpdateArc(gTargets); } +void STh::setMode(short mode) { + gMode = mode; +} +void STh::setTarget(QString target) { + this->target = target; +} +void STh::setPorts(QString ports) { + this->ports = ports; +} void STh::run() { - startScan(inputStr); + MainStarter ms(gMode, + this->target.toLocal8Bit().data(), + this->ports.toLocal8Bit().data() + ); + ms.start(); } diff --git a/STh.h b/STh.h index 61a8499..ec3a576 100644 --- a/STh.h +++ b/STh.h @@ -4,15 +4,22 @@ #pragma once #include "nesca_3.h" #include "externFunctions.h" +#include "MainStarter.h" extern int tMax; class STh : public QThread { Q_OBJECT -public: +private: + QString target = ""; + QString ports = ""; public: + void setMode(short mode); + void setTarget(QString target); + void setPorts(QString ports); + static void doEmitionDataSaved(bool status); static void doEmitionStartScanIP(); static void doEmitionStartScanDNS(); diff --git a/Threader.cpp b/Threader.cpp index f9d1b94..eb69281 100644 --- a/Threader.cpp +++ b/Threader.cpp @@ -24,8 +24,6 @@ void Threader::fireThread(std::string ip, void *func(void)) { void Threader::cleanUp() { ready = true; cv.notify_all(); - //Wait for threads to exit correctly - Sleep(gTimeOut*1000 + 2000); std::unique_lock lk(m); lk.unlock(); lk.release(); diff --git a/externData.h b/externData.h index 2f2bb1d..cf7cdb7 100644 --- a/externData.h +++ b/externData.h @@ -20,7 +20,7 @@ extern QJsonArray *jsonArr; -extern unsigned long long gTargetsOverall; +extern unsigned long long gTargetsNumber; extern long long unsigned int gTargets; extern volatile int cons, BrutingThrds, gThreads; extern char **loginLst, **passLst, **wfLoginLst, **wfPassLst, **sshlpLst, **GlobalNegatives; @@ -40,7 +40,7 @@ extern int found, indexIP, gMode, extern unsigned int Activity; extern char trcSrv[256], trcScr[256], trcProxy[128], trcPersKey[64], trcPort[32], trcSrvPortLine[32], saveEndIP[128], - gRange[128], gTLD[128], gPorts[65536], + gTLD[128], gPorts[65536], gProxyIP[64], gProxyPort[8], currentIP[MAX_ADDR_LEN], finalIP[32]; diff --git a/externFunctions.h b/externFunctions.h index e2d50d2..7707e17 100644 --- a/externFunctions.h +++ b/externFunctions.h @@ -4,12 +4,9 @@ extern std::string toLowerStr(const char *str); extern int startScan(char* argv); extern QString GetNSErrorDefinition(const char *str, const char *defin); -extern void _SaveBackupToFile(); extern char* strstri(const char *_Str, const char *_SubStr); -extern void nCleanup(); extern void getSubStr(char *src, char *startStr, char *endStr, char *dest, int szDest); extern void getSubStrEx(char *src, char *startStr, char *endStr, char *dest, int szDest); -extern void _SaveBackupToFile(); extern char *_findFirst(const char *str, char *delim); diff --git a/mainResources.h b/mainResources.h index 0107118..43ed324 100644 --- a/mainResources.h +++ b/mainResources.h @@ -2,8 +2,8 @@ #include "base64.h" #include -#include #include +#include #if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__) #include "iostream" #include diff --git a/nesca_3.cpp b/nesca_3.cpp index ba6fdb1..35875b1 100644 --- a/nesca_3.cpp +++ b/nesca_3.cpp @@ -45,7 +45,6 @@ bool smBit_7 = false; bool smBit_8 = false; bool privateMsgFlag = false; -char inputStr[256] = {0}; bool proxyEnabledFlag = false; bool disableBlink = false; char gVER[32] = {0}; @@ -175,10 +174,13 @@ void _LoadPersInfoToLocalVars(int savedTabIndex) { { if (ui->ipLine->text().indexOf("/") < 0) { - strcpy(currentIP, ui->ipLine->text().toLocal8Bit().data()); - strcat(currentIP, "-"); - strcat(currentIP, ui->ipLine->text().toLocal8Bit().data()); - }; + sprintf(currentIP, "%s-%s", + ui->ipLine->text().toLocal8Bit().data(), ui->ipLine->text().toLocal8Bit().data()); + } + else { + sprintf(currentIP, "%s", + ui->ipLine->text().toLocal8Bit().data()); + } }; strncpy(gPorts, ("-p" + ui->portLine->text()).toLocal8Bit().data(), 65536); @@ -270,7 +272,7 @@ void nesca_3::drawVerboseArcs(unsigned long gTargets) { fSz = 6; QPainterPath pathTargets; pathTargets.arcMoveTo(leftX, sharedY, rightX, sharedheight1, 0); - pathTargets.arcTo(leftX, nSharedY, rightX, sharedheight2, 0, indexIP*((float)(180/(float)gTargetsOverall))); + pathTargets.arcTo(leftX, nSharedY, rightX, sharedheight2, 0, indexIP*((float)(180/(float)gTargetsNumber))); QGraphicsPathItem* itmTargets = new QGraphicsPathItem(pathTargets); itmTargets->setPen(penTargets); testScene->addItem(itmTargets); @@ -278,7 +280,7 @@ void nesca_3::drawVerboseArcs(unsigned long gTargets) { fSz = 3; QPainterPath pathSaved; pathSaved.arcMoveTo(leftX, sharedY, rightX, sharedheight1, 0); - pathSaved.arcTo(leftX, nSharedY, rightX, sharedheight2, 0, saved*((float)(180/(float)gTargetsOverall))); + pathSaved.arcTo(leftX, nSharedY, rightX, sharedheight2, 0, saved*((float)(180/(float)gTargetsNumber))); QGraphicsPathItem* itmSaved = new QGraphicsPathItem(pathSaved); itmSaved->setPen(penSaved); testScene->addItem(itmSaved); @@ -2052,27 +2054,15 @@ void nesca_3::IPScanSeq() ui->tabMainWidget->setTabEnabled(1, false); ui->tabMainWidget->setTabEnabled(2, false); - QString rangeData = ui->ipLine->text(); - if(rangeData.indexOf("-") > 0) - { - rangeData = ui->ipLine->text(); - } - else - { - if(rangeData.indexOf("/") < 0) - { - rangeData = ui->ipLine->text() + "-" + ui->ipLine->text(); - } - else - { - rangeData = ui->ipLine->text(); - }; - }; - saveOptions(); - strcpy(inputStr, ("DUMMY|0|" + rangeData + "|" + ui->threadLine->text() + "|-p" + ui->portLine->text().replace(" ", "")).toLocal8Bit().data()); + stt->setMode(0); + stt->setTarget((ui->ipLine->text().indexOf("-") > 0 ? ui->ipLine->text() : + (ui->ipLine->text().indexOf("/") < 0 ? ui->ipLine->text() + "-" + ui->ipLine->text() : ui->ipLine->text()) + )); + stt->setPorts(ui->portLine->text().replace(" ", "")); stt->start(); + startFlag = true; ui->startScanButton_3->setText("Stop"); ui->startScanButton_3->setStyleSheet( @@ -2132,6 +2122,10 @@ void nesca_3::DNSScanSeq() { if(ui->lineEditStartIPDNS->text().indexOf(".") > 0) { + stopFirst = false; + ui->tabMainWidget->setTabEnabled(0, false); + ui->tabMainWidget->setTabEnabled(2, false); + QStringList lst = ui->lineEditStartIPDNS->text().split("."); ui->lineEditStartIPDNS->setText(lst[0]); QString topLevelDomainStr; @@ -2144,14 +2138,12 @@ void nesca_3::DNSScanSeq() }; saveOptions(); - stopFirst = false; - - ui->tabMainWidget->setTabEnabled(0, false); - ui->tabMainWidget->setTabEnabled(2, false); - - strcpy(inputStr, ("DUMMY|1|" + ui->lineEditStartIPDNS->text() + "|" + ui->lineILVL->text() + "|" + ui->lineEditThread->text() + "|-p" + ui->lineEditPort->text().replace(" ", "")).toLocal8Bit().data()); + stt->setMode(1); + stt->setTarget(ui->lineEditStartIPDNS->text()); + stt->setPorts(ui->lineEditPort->text().replace(" ", "")); stt->start(); + startFlag = true; ui->startScanButton_4->setText("Stop"); ui->startScanButton_4->setStyleSheet( @@ -2186,15 +2178,18 @@ void nesca_3::ImportScanSeq() if(fileName != "") { + stopFirst = false; ui->tabMainWidget->setTabEnabled(0, false); ui->tabMainWidget->setTabEnabled(1, false); _LoadPersInfoToLocalVars(savedTabIndex); - strcpy(inputStr, ("DUMMY|-f|" + fileName + "|" + ui->importThreads->text() + "|-p" + ui->importPorts->text().replace(" ", "")).toLocal8Bit().data()); - + + stt->setMode(-1); + stt->setTarget(fileName); + stt->setPorts(ui->importPorts->text().replace(" ", "")); stt->start(); + startFlag = true; - stopFirst = false; pbTh->start(); ui->importButton->setText("Stop"); ui->importButton->setStyleSheet( @@ -2350,7 +2345,9 @@ void nesca_3::ConnectEvrthng() connect ( ui->shuffle_onoff, SIGNAL(toggled(bool)), this, SLOT(ChangeShuffle(bool))); connect ( ui->trackerOnOff, SIGNAL(toggled(bool)), this, SLOT(ChangeTrackerOK(bool))); connect ( ui->importThreads, SIGNAL( textChanged(QString) ), this, SLOT( ChangeLabelThreads_ValueChanged(QString) ) ); - connect ( ui->threadLine, SIGNAL( textChanged(QString) ), this, SLOT( ChangeLabelThreads_ValueChanged(QString) ) ); + connect(ui->threadLine, SIGNAL(textChanged(QString)), this, SLOT(ChangeLabelThreads_ValueChanged(QString))); + connect(ui->lineILVL, SIGNAL(textChanged(QString)), this, SLOT(saveTLD(QString))); + connect ( ui->PingTO, SIGNAL( textChanged(QString) ), this, SLOT( PingTO_ChangeValue(QString) ) ); connect ( ui->threadDelayBox, SIGNAL( textChanged(QString) ), this, SLOT( ThreadDelay_ChangeValue(QString) ) ); connect ( ui->maxBrutingThrBox, SIGNAL( textChanged(QString) ), this, SLOT( MaxBrutingThr_ChangeValue(QString) ) ); @@ -2416,7 +2413,6 @@ void nesca_3::ConnectEvrthng() void nesca_3::saveOptions() { _LoadPersInfoToLocalVars(savedTabIndex); - _SaveBackupToFile(); } QString loadNescaSetup(const char *resStr, const char *option) { @@ -2470,28 +2466,22 @@ void RestoreSession() { if(strstr(lex, "-") != NULL) { - strncpy(gRange, lex, (int)(strstr(lex, "-") - lex)); - strcat(gRange, "-"); - strcat(gRange, strstr(lex, "-") + 1); + ui->ipLine->setText(QString(lex)); lex = strtok(NULL, " "); gThreads = atoi(lex); ui->threadLine->setText(QString(lex)); - ui->ipLine->setText(QString(gRange)); ui->tabMainWidget->setCurrentIndex(0); } else if(strstr(lex, "/") != NULL) { - strncpy(gRange, lex, (int)(strstr(lex, "/") - lex)); - strcat(gRange, "/"); - strcat(gRange, strstr(lex, "/") + 1); + ui->ipLine->setText(QString(lex)); lex = strtok(NULL, " "); gThreads = atoi(lex); ui->threadLine->setText(QString(lex)); - ui->ipLine->setText(QString(gRange)); ui->tabMainWidget->setCurrentIndex(0); }; } @@ -2812,6 +2802,7 @@ void nesca_3::exitButtonClicked() #if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__) WSACleanup(); #endif + Threader::cleanUp(); qApp->quit(); } @@ -2992,6 +2983,10 @@ void nesca_3::ChangeLabelThreads_ValueChanged(QString str) gThreads = str.toInt(); } +void nesca_3::saveTLD(QString str){ + strncpy(gTLD, str.toLocal8Bit().data(), 128); +} + void nesca_3::PingTO_ChangeValue(QString str) { gPingTimeout = str.toInt(); diff --git a/nesca_3.h b/nesca_3.h index 49d30c2..619bcd9 100644 --- a/nesca_3.h +++ b/nesca_3.h @@ -29,7 +29,6 @@ extern bool widgetIsHidden, blinkFlag, disableBlink, QOSWait, smBit_8, smBit_7, smBit_6, smBit_5, smBit_4, smBit_3, smBit_2, smBit_1, printDelimiter; extern float QoSStep; extern int MaxDataVal; -extern char inputStr[256]; extern SOCKET lSock; extern QVector vAlivLst, vAnomLst, vWFLst, vSuspLst, vLowlLst, vBALst, vSSHLst, vOvrlLst, actLst; @@ -61,6 +60,7 @@ protected: QString GetSSLContent(QString str); void SSLConnect(QString str); protected slots: + void saveTLD(QString str); void onLinkClicked(QUrl); void MaxBrutingThr_ChangeValue(QString str); void ThreadDelay_ChangeValue(QString val); diff --git a/nesca_startModule.cpp b/nesca_startModule.cpp index 24226ba..b427b44 100644 --- a/nesca_startModule.cpp +++ b/nesca_startModule.cpp @@ -2,58 +2,40 @@ #include "mainResources.h" #include "externData.h" #include "externFunctions.h" -#include "Connector.h" -#include "Threader.h" -#include "FileUpdater.h" -#include -QJsonArray *jsonArr = new QJsonArray(); - -bool gShuffle = true; bool __savingBackUpFile = false; -bool horLineFlag = false; -static int portArr[65536] = { 0 }; + int gThreadDelay = 10; int gC = 0; int gTimeOut = 3; int PieAnomC1 = 0, PieBA = 0, PieSusp = 0, PieLowl = 0, PieWF = 0, PieSSH = 0; int AnomC1 = 0, Filt = 0, Overl = 0, Lowl = 0, Alive = 0, saved = 0, Susp = 0, WF = 0, offlines = 0, ssh = 0; int GlobalNegativeSize = 0; -int ipCounter = 0; int found = 0, indexIP = 0; int gMode; int MaxPass = 0, MaxLogin = 0, MaxTags = 0, MaxWFLogin = 0, MaxWFPass = 0, MaxSSHPass = 0; int ipsstart[4], ipsend[4], -overallPorts, flCounter, octet[4]; +overallPorts, +octet[4]; int baCount = 0; int gPingTimeout = 1; int gMaxBrutingThreads = 50; unsigned int Activity = 0; -unsigned char **ipsstartfl = NULL, **ipsendfl = NULL, **starterIP = NULL; double ips = 0; char **GlobalNegatives = 0; char **loginLst, **passLst; char **wfLoginLst, **wfPassLst; char **sshlpLst; char saveEndIP[128] = { 0 }; -char gRange[128] = { 0 }; char gTLD[128] = { 0 }; char gPorts[65536] = { 0 }; -char metaRange[256] = { 0 }; -char metaPercent[256] = { 0 }; -char metaIPS[256] = { 0 }; -char metaTargets[256] = { 0 }; -char metaETA[256] = { 0 }; -char metaOffline[256] = { 0 }; char currentIP[MAX_ADDR_LEN] = { 0 }; -char currentMask[128] = { 0 }; char finalIP[32] = { 0 }; bool ErrLogFirstTime = true; bool gPingNScan = false; -long long unsigned int gTargets = 0, gTargetsOverall = 1, targets; volatile int gThreads; volatile int cons = 0; volatile int BrutingThrds = 0; @@ -92,66 +74,6 @@ std::string toLowerStr(const char *str) else return ""; } -void SaveErrorLog(char *sender, char *MesSent, char *ReplRecv) -{ - FILE *errFile = fopen("./logs/ns-track_errors.html", "r"); - if (errFile != NULL) - { - fclose(errFile); - }; -#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__) - CreateDirectory(L"./logs", NULL); -#else - struct stat st = {0}; - if (stat("./logs", &st) == -1) { - mkdir("./logs", 0700); - } -#endif - time_t rtime; - time(&rtime); - char cdate[32] = { 0 }; - strcpy(cdate, ctime(&rtime)); - - char *totalErrLog = NULL; - char stylePart[] = { "" }; - char firstPart[] = { "
" }; - char secondPart[] = { "
Message sent:
" };
-	char thirdPart[] = { "
Reply received:
" }; - - int sz = strlen(stylePart) + strlen(firstPart) + strlen(secondPart) + strlen(thirdPart) + strlen(forthPart) + strlen(QByteArray(MesSent).replace("\r\n", "\n").data()) + (strlen(ReplRecv) + 50 * strlen(ReplRecv) / 100) + strlen(cdate) + strlen(sender); - - totalErrLog = new char[sz + 4]; - ZeroMemory(totalErrLog, sz); - if (ErrLogFirstTime) strcat(totalErrLog, stylePart); - strcat(totalErrLog, firstPart); - strcat(totalErrLog, sender); - strcat(totalErrLog, " - "); - strcat(totalErrLog, cdate); - strcat(totalErrLog, secondPart); - strcat(totalErrLog, QByteArray(MesSent).replace("\r\n", "\n").data()); - strcat(totalErrLog, thirdPart); - strcat(totalErrLog, base64_encode((const unsigned char *)ReplRecv, strlen(ReplRecv)).c_str()); - strcat(totalErrLog, forthPart); - memset(totalErrLog + sz, '\0', 1); - - errFile = fopen("./logs/ns-track_errors.html", "a"); - if (errFile != NULL) - { - fwrite(totalErrLog, sz, 1, errFile); - fclose(errFile); - } - else - { - stt->doEmitionRedFoundData("[Log] -Cant open log file!"); - }; - if (totalErrLog != NULL) - { - delete[]totalErrLog; - totalErrLog = NULL; - }; -} - QString GetNSErrorDefinition(const char *str, const char *elem) { const char *temp = strstr(str, elem); @@ -171,586 +93,6 @@ QString GetNSErrorDefinition(const char *str, const char *elem) else return QString("No definition found!"); } -void _SaveBackupToFile() -{ - char saveStr[512] = { 0 }; - char saveBuffer[4096] = { 0 }; - char endStr[128] = { 0 }; - - if (gMode == 0 || gMode == 1) - { - if (gMode == 1) - { - if (strlen(currentMask) == 0) { - sprintf(endStr, "%s", currentIP); - } - else strcpy(endStr, currentMask); - } - else - { - sprintf(endStr, "%s-%s", currentIP, finalIP); - }; - - if (strlen(endStr) > 0) - { - sprintf(saveStr, "[SESSION]:%d %s %s %d %s\n", - gMode, endStr, gTLD, gThreads, gPorts); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - }; - } - else if (gMode == -1) - { - char ipRange[128] = { 0 }; - - if (flCounter > 0) - { - FILE *savingFile = fopen("tempIPLst.bk", "w"); - if (savingFile != NULL) - { - sprintf(ipRange, "%s-%d.%d.%d.%d\n", - currentIP, - ipsendfl[gC][0], ipsendfl[gC][1], ipsendfl[gC][2], ipsendfl[gC][3]); - fputs(ipRange, savingFile); - - ZeroMemory(ipRange, sizeof(ipRange)); - for (int tCounter = gC + 1; tCounter < flCounter; ++tCounter) - { - sprintf(ipRange, "%d.%d.%d.%d-%d.%d.%d.%d\n", - ipsstartfl[tCounter][0], ipsstartfl[tCounter][1], ipsstartfl[tCounter][2], ipsstartfl[tCounter][3], - ipsendfl[tCounter][0], ipsendfl[tCounter][1], ipsendfl[tCounter][2], ipsendfl[tCounter][3]); - - fputs(ipRange, savingFile); - - ZeroMemory(ipRange, sizeof(ipRange)); - }; - fclose(savingFile); - } - else stt->doEmitionRedFoundData("[_saver] Cannot open file."); - }; - - sprintf(saveStr, "[SESSION]:%d RESTORE_IMPORT_SESSION %d %s\n", gMode, gThreads, gPorts); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - }; - - sprintf(saveStr, "[NDBSERVER]:%s\n", trcSrv); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[NDBSCRIPT]:%s\n", trcScr); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[NDBPORT]:%s\n", trcSrvPortLine); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[PROXY]:%s\n", trcProxy); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[PROXYPORT]:%s\n", trcPort); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[PING]:%s\n", gPingNScan ? "true" : "false"); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[SHUFFLE]:%s\n", gShuffle ? "true" : "false"); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[NSTRACK]:%s\n", trackerOK ? "true" : "false"); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[PING_TO]: %d\n", gPingTimeout); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[THREAD_DELAY]: %d\n", gThreadDelay); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[TIMEOUT]: %d\n", gTimeOut); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[MAXBTHR]: %d\n", gMaxBrutingThreads); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[SYSTEMPROXYIP]: %s\n", gProxyIP); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - sprintf(saveStr, "[SYSTEMPROXYPORT]: %s\n", gProxyPort); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - strcpy(saveStr, "[PERSKEY]:"); - strncat(saveStr, trcPersKey, 32); - strcat(saveStr, "\n"); - strcat(saveBuffer, saveStr); - ZeroMemory(saveStr, sizeof(saveStr)); - - FILE *savingFile = fopen("restore", "w"); - - if (savingFile != NULL) - { - fputs(saveBuffer, savingFile); - fclose(savingFile); - } - else stt->doEmitionRedFoundData("[_saver] Cannot open file."); - - ZeroMemory(saveStr, strlen(saveStr)); - ZeroMemory(saveBuffer, strlen(saveBuffer)); -} - -bool saverRunning = false; -void _saver() -{ - saverRunning = true; - Sleep(1000); - while (globalScanFlag) - { - __savingBackUpFile = true; - _SaveBackupToFile(); - __savingBackUpFile = false; - Sleep(10000); - }; - saverRunning = false; -} - -bool timerRunning = false; -void _timer() { - timerRunning = true; - char dbuffer[32] = { 0 }, timeLeft[64] = { 0 }, b[32] = { 0 }; - int ticks = 0; - int ovrlIPs = 0; - ips = 1; - Sleep(50); - - while (globalScanFlag) - { - ++ticks; - ovrlIPs += ipCounter; - ipCounter = 0; - ips = ovrlIPs / ticks; - strncpy(b, QString::number(ips).toLocal8Bit().data(), 5); - - strcpy(metaIPS, b); - //strcat(timeLeft, b); - //strcat(timeLeft, "/s ("); - - //if (ips > 0) - //{ - // strncpy(dbuffer, std::to_string(((gTargets + 1) / ips / 3600 / 24)).c_str(), 5); - //} - //else strcpy(dbuffer, "INF"); - //strcpy(metaETA, dbuffer); - //strcat(dbuffer, "d)"); - //strcat(timeLeft, (strcmp(dbuffer, "1.$d)") == 0 ? "INF)" : dbuffer)); - - //ZeroMemory(timeLeft, sizeof(timeLeft)); - //ZeroMemory(dbuffer, sizeof(dbuffer)); - - Sleep(1000); - }; - timerRunning = false; -} - -bool trackerRunning = false; -void _tracker() { - trackerRunning = true; - while (true) { - while (globalScanFlag && !trackerOK) Sleep(1000); - - if (!globalScanFlag && jsonArr->size() == 0) break; - char rBuffT[250000] = { 0 }; - char *msg = new char[4096]; - ZeroMemory(msg, sizeof(*msg)); - char ndbServer[64] = { 0 }; - char ndbScriptT[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, trcScr); - strcat(msg, " HTTP/1.1\r\nHost: "); - strcat(msg, trcSrv); - strcat(msg, "\r\nX-Nescav3: True\r\nContent-Type: application/x-www-form-urlencoded\r\nConnection: close\r\n\r\n"); - - HOSTENT *host; - -#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__) - 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); - - if (connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)) == -1) - { - CSSOCKET(sock); - - stt->doEmitionRedFoundData("[NS-Track] -Cannot connect to balancer! " + QString::number(WSAGetLastError()) + "."); - - continue; - }; - - if (send(sock, msg, strlen(msg), 0) == -1) - { - CSSOCKET(sock); - - stt->doEmitionRedFoundData("[NS-Track] -Cannot send to balancer! " + QString::number(WSAGetLastError()) + "."); - - continue; - }; - - ZeroMemory(rBuffT, sizeof(rBuffT)); - char rBuff[512] = { 0 }; - int test = recv(sock, rBuff, sizeof(rBuff), 0); - strcpy(rBuffT, rBuff); - - while ((test = recv(sock, rBuff, sizeof(rBuff), 0)) != 0) - { - if (strlen(rBuffT) > 200000) - { - stt->doEmitionRedFoundData("[NS-Track] (Outer) -Large error received from server (>200000b) " + QString::number(WSAGetLastError()) + "."); - SaveErrorLog("NS-Track", msg, rBuffT); - break; - }; - strcat(rBuffT, rBuff); - }; - - if (test == -1) - { - CSSOCKET(sock); - - stt->doEmitionRedFoundData("[NS-Track] -Cannot recv from balancer! " + QString::number(WSAGetLastError()) + "."); - - continue; - }; - - char *t1; - char *t2; - if (strstr(rBuffT, "http://") != NULL) - { - t1 = strstr(rBuffT, "http://"); - if (strstr((char*)(t1 + 7), "/") != NULL) - { - t2 = strstr((char*)(t1 + 7), "/"); - int ln = t2 - t1 - 7; - if (ln > 64) - { - CSSOCKET(sock); - - stt->doEmitionRedFoundData("[NS-Track] -Received server string is not valid!"); - SaveErrorLog("NS-Track", msg, rBuffT); - - continue; - } - else strncpy(ndbServer, (char*)(t1 + 7), ln); - - if (strlen(t2) > 64) - { - - stt->doEmitionYellowFoundData("[NS-Track] -Fragmentation detected!"); - - if (strstr(t2, "\r\n") != NULL) - { - char *t3 = strstr(t2, "\r\n"); - int y = (int)(t3 - t2); - - if (y > 64) - { - CSSOCKET(sock); - - stt->doEmitionRedFoundData("[NS-Track] -Received server string is not valid!"); - - SaveErrorLog("NS-Track", msg, rBuffT); - continue; - } - else - { - strncpy(ndbScriptT, t2, y); - CSSOCKET(sock); - - stt->doEmitionGreenFoundData("[NS-Track] -OK! -Fragmented server string aquired! Starting NS-Track loop..."); - - strncpy(ndbScript, ndbScriptT, strlen(ndbScriptT)); - }; - } - else - { - CSSOCKET(sock); - - stt->doEmitionRedFoundData("[NS-Track] -Received server string is not valid!"); - - SaveErrorLog("NS-Track", msg, rBuffT); - continue; - }; - } - else - { - strcpy(ndbScriptT, t2); - - stt->doEmitionGreenFoundData("[NS-Track] -OK! -Server string aquired! Starting NS-Track loop..."); - - CSSOCKET(sock); - strncpy(ndbScript, ndbScriptT, strlen(ndbScriptT) - 2); - }; - } - else - { - CSSOCKET(sock); - - stt->doEmitionRedFoundData("[NS-Track] -Cannot receive script value!"); - - continue; - }; - - ZeroMemory(rBuffT, sizeof(rBuffT)); - CSSOCKET(sock); - - while (true) - { - if (!globalScanFlag && jsonArr->size() == 0) break; - if (!trackerOK) { - Sleep(1000); - continue; - }; - - if (jsonArr->size() > 0) - { - QJsonObject jsonKey; - if (jsonArr == NULL) jsonArr = new QJsonArray(); - - QJsonObject jsonMeta; - if (gMode == 0) jsonMeta.insert("mode", QJsonValue(QString("IP"))); // - else if (gMode == 1) jsonMeta.insert("mode", QJsonValue(QString("DNS"))); //Mode - else if (gMode == -1) jsonMeta.insert("mode", QJsonValue(QString("Import"))); // - jsonMeta.insert("range", QJsonValue(QString(metaRange))); - jsonMeta.insert("current", QJsonValue(QString(currentIP))); - if (gMode == 1) jsonMeta.insert("tld", QJsonValue(QString(gTLD))); //TLD - jsonMeta.insert("targets", QJsonValue(QString(metaTargets))); - jsonMeta.insert("percent", QJsonValue(QString(metaPercent))); - jsonMeta.insert("saved", QJsonValue(QString::number(saved))); - jsonMeta.insert("found", QJsonValue(QString::number(found))); - jsonMeta.insert("speed", QJsonValue(QString(metaIPS))); - jsonMeta.insert("eta", QJsonValue(QString(metaETA))); - jsonMeta.insert("threads", QJsonValue(QString::number(cons) + "/" + QString::number(gThreads))); - jsonMeta.insert("bads", QJsonValue(QString::number(offlines))); - jsonMeta.insert("version", QJsonValue(QString(gVER))); - - jsonArr->push_front(QJsonValue(jsonMeta)); - memset(trcPersKey + 32, '\0', 1); - jsonKey.insert("key", QJsonValue(QString(trcPersKey))); - jsonArr->push_front(jsonKey); - - QJsonDocument js; - js.setArray(*jsonArr); - QByteArray r = js.toJson(); - - sockAddr.sin_family = AF_INET; - sockAddr.sin_port = htons(atoi(trcSrvPortLine)); - - if (msg != NULL) - { - delete[]msg; - msg = 0; - }; - - msg = new char[r.size() + 1024]; - ZeroMemory(msg, sizeof(*msg)); - - strcpy(msg, "POST /"); - strcat(msg, ndbScript); - strcat(msg, " HTTP/1.1\r\nHost: "); - strcat(msg, ndbServer); - strcat(msg, "\r\nContent-Type: application/json\r\nAccept-Encoding: application/json\r\nContent-Length: "); - strcat(msg, std::to_string(r.size()).c_str()); - strcat(msg, "\r\nConnection: close\r\n\r\n"); - - strcat(msg, r.data()); - - delete jsonArr; - jsonArr = new QJsonArray(); - -#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__) - 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); - - if (gDebugMode) - { - stt->doEmitionDebugFoundData("Connecting to " + QString(ndbServer)); - }; - - if (connect(sock, (sockaddr*)&sockAddr, sizeof(sockAddr)) == -1) - { - CSSOCKET(sock); - - - stt->doEmitionRedFoundData("[NS-Track] -connect() returned " + QString::number(WSAGetLastError()) + "."); - - continue; - }; - - if (gDebugMode) - { - stt->doEmitionDebugFoundData("Sending!"); - stt->doEmitionDebugFoundData("Key: [" + QString(trcPersKey) + "]"); - stt->doEmitionDebugFoundData("MSG: [" + QString(msg) + "]"); - }; - - if (send(sock, msg, strlen(msg), 0) == -1) - { - CSSOCKET(sock); - - stt->doEmitionRedFoundData("[NS-Track] -send() returned " + QString::number(WSAGetLastError()) + "."); - - SaveErrorLog("NS-Track", msg, ""); - continue; - }; - - ZeroMemory(rBuffT, sizeof(rBuffT)); - char msgR[32] = { 0 }; - - if (gDebugMode) - { - stt->doEmitionDebugFoundData("Receiving..."); - }; - - test = recv(sock, rBuff, 512, 0); - - if (gDebugMode) - { - stt->doEmitionDebugFoundData("Received: " + QString(rBuff)); - }; - - strncpy(msgR, rBuff, 32); - strcpy(rBuffT, rBuff); - while (test > 0) - { - if (test <= 0) break; - - if (strlen(rBuffT) > 200000) - { - stt->doEmitionRedFoundData("[NS-Track] (Inner) -Large error received from server (>200000b) " + QString::number(WSAGetLastError()) + "."); - SaveErrorLog("NS-Track", msg, rBuffT); - break; - }; - strcat(rBuffT, rBuff); - test = recv(sock, rBuff, 512, 0); - if (gDebugMode) - { - stt->doEmitionDebugFoundData("Received: " + QString(rBuff)); - }; - }; - - if (test == -1) - { - CSSOCKET(sock); - - stt->doEmitionRedFoundData("[NS-Track] -recv() returned " + QString::number(WSAGetLastError()) + "."); - - SaveErrorLog("NS-Track", msg, ""); - continue; - }; - - if (strstr(rBuffT, "201 Created") != NULL) - { - - if (gDebugMode) stt->doEmitionYellowFoundData("[NS-Track] -OK. Data saved!"); - stt->doEmitionDataSaved(true); - Sleep(1000); - stt->doEmitionDataSaved(false); - - } - else if (strstr(rBuffT, "400 Bad Request") != NULL) - { - - QString errorDef = GetNSErrorDefinition(rBuffT, "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 : " + errorDef + "]"); - - SaveErrorLog("NS-Track", msg, rBuffT); - } - else - { - stt->doEmitionYellowFoundData("[NS-Track] -FAIL! An error occured [" + QString(msgR) + "]"); - SaveErrorLog("NS-Track", msg, rBuffT); - }; - - ZeroMemory(msgR, sizeof(msgR)); - ZeroMemory(rBuffT, sizeof(rBuffT)); - ZeroMemory(msg, sizeof(*msg)); - - if (msg != NULL) - { - delete msg; - msg = NULL; - }; - - CSSOCKET(sock); - }; - Sleep(10000); - }; - } - else - { - stt->doEmitionRedFoundData("[NS-Track] -Balancer replied with invalid string."); - SaveErrorLog("NS-Track", msg, rBuffT); - }; - - CSSOCKET(sock); - } - - trackerRunning = false; -} - -unsigned long int numOfIps(int ipsstart[], int ipsend[]) { - gTargets += 16777216 * (ipsend[0] - ipsstart[0]); - gTargets += 65536 * (ipsend[1] - ipsstart[1]); - gTargets += 256 * (ipsend[2] - ipsstart[2]); - gTargets += (ipsend[3] - ipsstart[3]); - gTargetsOverall = gTargets + 1; - - //unsigned long ip1 = (ipsstart[0] * 16777216) + (ipsstart[1] * 65536) + (ipsstart[2] * 256) + ipsstart[3]; - //unsigned long ip2 = (ipsend[0] * 16777216) + (ipsend[1] * 65536) + (ipsend[2] * 256) + ipsend[3]; - //unsigned long gTargets = ip2 - ip1; - - return gTargets; -} - -void verboseProgress(unsigned long target) { - - stt->doEmitionUpdateArc(gTargets); - if(gTargets > 0) --gTargets; - - char targetNPers[128] = { 0 }; - float percent = (gTargetsOverall != 0 ? (100 - target / (double)gTargetsOverall * 100) : 0); - - sprintf(targetNPers, "%Lu (%.1f%%)", target, percent); - - sprintf(metaTargets, "%Lu", target); - sprintf(metaPercent, "%.1f", - percent); -} - #if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__) unsigned char* ASCIItoUNICODE(unsigned char ch) { @@ -791,1344 +133,3 @@ std::string xcode(LPCSTR src, UINT srcCodePage, UINT dstCodePage) { #endif return res; } - -void CheckMaskBits(char *res, int index) { - char *bitsStr = strstr(res, "/"); - int bitsNum = atoi(bitsStr + 1); - int finalBit = 1; - int bitCounter = 0; - - if (bitsNum <= 32 && bitsNum > 24) //4 octet - { - bitCounter = 32 - bitsNum; - for (int i = 0; i < bitCounter; i++) finalBit *= 2; - ipsstartfl[index][0] = ipsendfl[index][0] = octet[0]; - ipsstartfl[index][1] = ipsendfl[index][1] = octet[1]; - ipsstartfl[index][2] = ipsendfl[index][2] = octet[2]; - ipsstartfl[index][3] = octet[3]; - ipsendfl[index][3] = octet[3] + finalBit - 1; - - } - else if (bitsNum <= 24 && bitsNum > 16) //3 octet - { - bitCounter = 24 - bitsNum; - for (int i = 0; i < bitCounter; i++) finalBit *= 2; - ipsstartfl[index][0] = ipsendfl[index][0] = octet[0]; - ipsstartfl[index][1] = ipsendfl[index][1] = octet[1]; - ipsstartfl[index][2] = octet[2]; - ipsendfl[index][2] = octet[2] + finalBit - 1; - ipsstartfl[index][3] = octet[3]; - ipsendfl[index][3] = 255; - } - else if (bitsNum <= 16 && bitsNum > 8) //2 octet - { - bitCounter = 16 - bitsNum; - for (int i = 0; i < bitCounter; i++) finalBit *= 2; - ipsstartfl[index][0] = ipsendfl[index][0] = octet[0]; - ipsstartfl[index][1] = octet[1]; - ipsendfl[index][1] = octet[1] + finalBit - 1; - ipsstartfl[index][2] = octet[2]; - ipsendfl[index][2] = 255; - ipsstartfl[index][3] = octet[3]; - ipsendfl[index][3] = 255; - - } - else if (bitsNum <= 8 && bitsNum > 0) //1 octet - { - bitCounter = 8 - bitsNum; - for (int i = 0; i < bitCounter; i++) finalBit *= 2; - ipsstartfl[index][0] = octet[0]; - ipsendfl[index][0] = octet[0] + finalBit - 1; - ipsstartfl[index][1] = octet[1]; - ipsendfl[index][1] = 255; - ipsstartfl[index][2] = octet[2]; - ipsendfl[index][2] = 255; - ipsstartfl[index][3] = octet[3]; - ipsendfl[index][3] = 255; - } - else - { - stt->doEmitionRedFoundData("[CheckMaskBits] Cannot parse IP list"); - stt->doEmitionKillSttThread(); - }; -} - -void GetOctets(char *curIP) { - char *str1; - char *str2; - char temp[8] = { 0 }; - - if (strstr(curIP, ".") != NULL) - { - str1 = strstr(curIP, "."); //1 - strncpy(temp, curIP, str1 - curIP); - octet[0] = atoi(temp); - - ZeroMemory(temp, sizeof(temp)); - } - else - { - str1 = strstr(curIP, "/"); - strncpy(temp, curIP, str1 - curIP); - - octet[0] = atoi(temp); - octet[1] = 0; - octet[2] = 0; - octet[3] = 0; - return; - }; - - if (strstr(str1 + 1, ".") != NULL) - { - str2 = strstr(str1 + 1, "."); //2 - strncpy(temp, str1 + 1, str2 - str1); - octet[1] = atoi(temp); - - ZeroMemory(temp, sizeof(temp)); - } - else - { - str2 = strstr(str1 + 1, "/"); - strncpy(temp, str1 + 1, str2 - str1); - - octet[1] = atoi(temp); - octet[2] = 0; - octet[3] = 0; - return; - }; - - if (strstr(str2 + 1, ".") != NULL) - { - str1 = strstr(str2 + 1, "."); //3 - strncpy(temp, str2 + 1, str1 - str2); - octet[2] = atoi(temp); - - ZeroMemory(temp, sizeof(temp)); - } - else - { - str1 = strstr(str2 + 1, "/"); - strncpy(temp, str2 + 1, str1 - str2); - - octet[2] = atoi(temp); - octet[3] = 0; - return; - }; - - if (strstr(str1 + 1, ".") != NULL) - { - str2 = strstr(str1 + 1, "."); //4 - strncpy(temp, str1 + 1, str2 - str1); - octet[3] = atoi(temp); - - ZeroMemory(temp, sizeof(temp)); - } - else - { - str2 = strstr(str1 + 1, "/"); - strncpy(temp, str1 + 1, str2 - str1 - 1); - - octet[3] = atoi(temp); - return; - }; -} - -void FileLoader(char *str) { - char curIP[256] = { 0 }, curIPCopy[256] = { 0 }; - unsigned int importFileSize = 0; - - FILE *fl = fopen(str, "r"); - if (fl != NULL) - { - while (fgets((char*)curIP, sizeof(curIP), fl) != NULL) - { - if (curIP[0] != '#' && curIP[0] != ' ' && curIP[0] != '\n' && curIP[0] != '\r' && strcmp(curIP, "") != 0 && - ((curIP[0] == '/' && curIP[1] == '/') == false) && ((curIP[0] == '\t' && curIP[1] == '\t' && curIP[2] == '\t' && (curIP[3] == 13 || curIP[3] == 10 || curIP[3] == '#')) == false) - && (curIP[0] == '\t' && curIP[1] == '\t' && curIP[2] == '\t' && (curIP[3] == '/' && curIP[4] == '/')) == false) - { - ++importFileSize; - }; - ZeroMemory(curIP, sizeof(curIP)); - }; - - ipsstartfl = new unsigned char*[importFileSize + 2]; - ipsendfl = new unsigned char*[importFileSize + 2]; - starterIP = new unsigned char*[importFileSize + 2]; - ZeroMemory(ipsstartfl, importFileSize); - ZeroMemory(ipsendfl, importFileSize); - ZeroMemory(starterIP, importFileSize); - for (int i = 0; i < importFileSize; ++i) - { - ipsstartfl[i] = new unsigned char[4]; - ipsendfl[i] = new unsigned char[4]; - starterIP[i] = new unsigned char[4]; - - ZeroMemory(ipsstartfl[i], 4); - ZeroMemory(ipsendfl[i], 4); - ZeroMemory(starterIP[i], 4); - }; - - rewind(fl); - - while (fgets(curIP, 256, fl) != NULL) - { - if (curIP[0] != '#' && curIP[0] != ' ' && curIP[0] != '\n' && curIP[0] != '\r' && strcmp(curIP, "") != 0 && - ((curIP[0] == '/' && curIP[1] == '/') == false) && ((curIP[0] == '\t' && curIP[1] == '\t' && curIP[2] == '\t' && (curIP[3] == 13 || curIP[3] == 10 || curIP[3] == '#')) == false) - && (curIP[0] == '\t' && curIP[1] == '\t' && curIP[2] == '\t' && (curIP[3] == '/' && curIP[4] == '/')) == false) - { - strcpy(curIPCopy, curIP); - char *ptr1 = strstr(curIP, " "); - if (ptr1 != NULL) curIP[(int)(ptr1 - curIP)] = '\0'; - ptr1 = strstr(curIP, " "); - if (ptr1 != NULL) curIP[(int)(ptr1 - curIP) - 1] = '\0'; - ptr1 = strstr(curIP, "#"); - if (ptr1 != NULL) curIP[(int)(ptr1 - curIP) - 1] = '\0'; - if (strcmp(curIP, "") == 0 || strcmp(curIP, " ") == 0 || strcmp(curIP, "\r\n") == 0 || strcmp(curIP, "\n") == 0 || curIP[0] == ' ' || curIP[0] == '#') - { - ZeroMemory(curIPCopy, sizeof(curIPCopy)); - ZeroMemory(curIP, sizeof(curIP)); - continue; - }; - - if (strstr(curIP, "-") != NULL) - { - bool firstPart = true; - int offset = 0; - int curNIndex = 0; - char curS; - char curN[32] = { 0 }; - for (int i = 0; i < strlen(curIP); ++i) - { - curS = curIP[i]; - if (curS == '.') - { - if (firstPart) - { - starterIP[flCounter][offset] = atoi(curN); - ipsstartfl[flCounter][offset] = atoi(curN); - } - else ipsendfl[flCounter][offset] = atoi(curN); - ++offset; - curNIndex = 0; - ZeroMemory(curN, 32); - continue; - } - else if (curS == '-') - { - if (firstPart) - { - starterIP[flCounter][offset] = atoi(curN); - ipsstartfl[flCounter][offset] = atoi(curN); - } - else ipsendfl[flCounter][offset] = atoi(curN); - offset = 0; - firstPart = false; - curNIndex = 0; - ZeroMemory(curN, 32); - continue; - }; - curN[curNIndex++] = curS; - if (i == strlen(curIP) - 1) - { - ipsendfl[flCounter][offset] = atoi(curN); - }; - }; - - if (ipsstartfl[flCounter][0] > ipsendfl[flCounter][0] - || (ipsstartfl[flCounter][0] >= ipsendfl[flCounter][0] - && ipsstartfl[flCounter][1] > ipsendfl[flCounter][1] - ) - || (ipsstartfl[flCounter][0] >= ipsendfl[flCounter][0] - && ipsstartfl[flCounter][1] >= ipsendfl[flCounter][1] - && ipsstartfl[flCounter][2] > ipsendfl[flCounter][2] - ) - || (ipsstartfl[flCounter][0] >= ipsendfl[flCounter][0] - && ipsstartfl[flCounter][1] >= ipsendfl[flCounter][1] - && ipsstartfl[flCounter][2] >= ipsendfl[flCounter][2] - && ipsstartfl[flCounter][3] > ipsendfl[flCounter][3] - ) - ) - { - char tempMsg[256] = { 0 }; - strcpy(tempMsg, "[IP Loader]Wrong list format. Line-> ["); - strcat(tempMsg, std::to_string(flCounter).c_str()); - strcat(tempMsg, "] String-> ["); - strcat(tempMsg, curIPCopy); - strcat(tempMsg, "]"); - stt->doEmitionRedFoundData(QString(tempMsg)); - return; - }; - - gTargets += 256 * 256 * 256 * (ipsendfl[flCounter][0] - ipsstartfl[flCounter][0]); - gTargets += 256 * 256 * (ipsendfl[flCounter][1] - ipsstartfl[flCounter][1]); - gTargets += 256 * (ipsendfl[flCounter][2] - ipsstartfl[flCounter][2]); - gTargets += (ipsendfl[flCounter][3] - ipsstartfl[flCounter][3]); - ++flCounter; - } - else if (strstr(curIP, "/") != NULL) - { - int mask = 0; - char *ptr1 = strstr(curIP, "/"); - GetOctets(curIP); - - mask = atoi(ptr1 + 1); - unsigned char mOctet[4]; - mOctet[0] = 1; - mOctet[1] = 1; - mOctet[2] = 1; - mOctet[3] = 1; - - if (mask >= 24) - { - mOctet[0] = 255; - mOctet[1] = 255; - mOctet[2] = 255; - for (int i = 0; i < mask - 24 - 1; ++i) - { - mOctet[3] = mOctet[3] << 1; - mOctet[3] |= 1; - }; - mOctet[3] = mOctet[3] << 8 - (mask - 24); - } - else if (mask >= 16) - { - mOctet[0] = 255; - mOctet[1] = 255; - for (int i = 0; i < mask - 16 - 1; ++i) - { - mOctet[2] = mOctet[2] << 1; - mOctet[2] |= 1; - }; - mOctet[2] = mOctet[2] << 8 - (mask - 16); - mOctet[3] = 0; - } - else if (mask >= 8) - { - mOctet[0] = 255; - for (int i = 0; i < mask - 8 - 1; ++i) - { - mOctet[1] = mOctet[1] << 1; - mOctet[1] |= 1; - }; - mOctet[1] = mOctet[1] << 8 - (mask - 8); - mOctet[2] = 0; - mOctet[3] = 0; - } - else - { - for (int i = 0; i < mask - 1; ++i) - { - mOctet[0] = mOctet[0] << 1; - mOctet[0] |= 1; - }; - mOctet[0] = mOctet[0] << 8 - mask; - mOctet[1] = 0; - mOctet[2] = 0; - mOctet[3] = 0; - }; - - unsigned char ocRes = 0; - for (int i = 0; i < 4; ++i) - { - ocRes = octet[i] & mOctet[i]; - starterIP[flCounter][i] = ocRes; - ipsstartfl[flCounter][i] = ocRes; - if (mOctet[i] == 255) ipsendfl[flCounter][i] = octet[i]; - else ipsendfl[flCounter][i] = octet[i] | ~mOctet[i]; - }; - - gTargets += pow((float)2, (32 - mask)); - ++flCounter; - } - else if (strstr(curIP, "RESTORE_IMPORT_SESSION") != NULL) - { - ///DUMMY/// - } - else - { - char tempMsg[256] = { 0 }; - strcpy(tempMsg, "[IP Loader]Wrong list format. Line-> ["); - strcat(tempMsg, std::to_string(flCounter).c_str()); - strcat(tempMsg, "] String-> ["); - strcat(tempMsg, curIPCopy); - strcat(tempMsg, "]"); - stt->doEmitionRedFoundData(QString(tempMsg)); - return; - }; - ZeroMemory(curIP, sizeof(curIP)); - }; - }; - gTargets -= 1; - gTargetsOverall = gTargets; - targets = gTargets; - - stt->doEmitionYellowFoundData("List loader - [OK] (" + QString::number(gTargetsOverall + 1) + " hosts)"); - fclose(fl); - } - else - { - stt->doEmitionRedFoundData("[IP Loader] Cannot open IP list."); - }; -} - -char *GetCIDRRangeStr(char *str) { - char result[128] = { 0 }; - char start[32] = { 0 }; - char end[32] = { 0 }; - - int mask = 0; - char *ptr1 = strstr(str, "/"); - GetOctets(str); - - mask = atoi(ptr1 + 1); - unsigned char mOctet[4]; - mOctet[0] = 1; - mOctet[1] = 1; - mOctet[2] = 1; - mOctet[3] = 1; - - if (mask >= 24) - { - mOctet[0] = 255; - mOctet[1] = 255; - mOctet[2] = 255; - for (int i = 0; i < mask - 24 - 1; ++i) - { - mOctet[3] = mOctet[3] << 1; - mOctet[3] |= 1; - }; - mOctet[3] = mOctet[3] << 8 - (mask - 24); - } - else if (mask >= 16) - { - mOctet[0] = 255; - mOctet[1] = 255; - for (int i = 0; i < mask - 16 - 1; ++i) - { - mOctet[2] = mOctet[2] << 1; - mOctet[2] |= 1; - }; - mOctet[2] = mOctet[2] << 8 - (mask - 16); - mOctet[3] = 0; - } - else if (mask >= 8) - { - mOctet[0] = 255; - for (int i = 0; i < mask - 8 - 1; ++i) - { - mOctet[1] = mOctet[1] << 1; - mOctet[1] |= 1; - }; - mOctet[1] = mOctet[1] << 8 - (mask - 8); - mOctet[2] = 0; - mOctet[3] = 0; - } - else - { - for (int i = 0; i < mask - 1; ++i) - { - mOctet[0] = mOctet[0] << 1; - mOctet[0] |= 1; - }; - mOctet[0] = mOctet[0] << 8 - mask; - mOctet[1] = 0; - mOctet[2] = 0; - mOctet[3] = 0; - }; - - - sprintf(start, "%d.%d.%d.%d", octet[0] & mOctet[0], - octet[1] & mOctet[1], - octet[2] & mOctet[2], - octet[3] & mOctet[3]); - - unsigned char tempRes0 = 0; - unsigned char tempRes1 = 0; - unsigned char tempRes2 = 0; - unsigned char tempRes3 = 0; - - if (mOctet[0] == 255) tempRes0 = octet[0]; - else tempRes0 = octet[0] | ~mOctet[0]; - if (mOctet[1] == 255) tempRes1 = octet[1]; - else tempRes1 = octet[1] | ~mOctet[1]; - if (mOctet[2] == 255) tempRes2 = octet[2]; - else tempRes2 = octet[2] | ~mOctet[2]; - if (mOctet[3] == 255) tempRes3 = octet[3]; - else tempRes3 = octet[3] | ~mOctet[3]; - - sprintf(end, "%d.%d.%d.%d", tempRes0, - tempRes1, - tempRes2, - tempRes3); - - sprintf(result, "%s-%s", start, end); - - return result; -} - -int fInit(int InitMode, char *gR) { - strcpy(metaRange, gR); - if (InitMode == 0) - { - if (strstr(gR, "/") != NULL) - { - ++flCounter; - - char *str1; - char *str2; - char res[8] = { 0 }; - - GetOctets(gR); - - if (strstr(gR, ".") != NULL) - { - str1 = strstr(gR, "."); //1 byte - strncpy(res, gR, (int)((char*)str1 - gR)); - } - else strcpy(res, gR); - - if (strstr(res, "/") != NULL) - { - CheckMaskBits(res, flCounter); - } - else - { - starterIP[flCounter][0] = atoi(res); - ipsstartfl[flCounter][0] = atoi(res); - ipsendfl[flCounter][0] = atoi(res); - }; - ZeroMemory(res, sizeof(res)); - - if (strstr(str1 + 1, ".") != NULL) - { - str2 = strstr(str1 + 1, "."); //2 byte - strncpy(res, str1 + 1, (int)((char*)str2 - str1) - 1); - } - else strcpy(res, str1 + 1); - - if (strstr(res, "/") != NULL) - { - CheckMaskBits(res, flCounter); - } - else - { - starterIP[flCounter][1] = atoi(res); - ipsstartfl[flCounter][1] = atoi(res); - ipsendfl[flCounter][1] = atoi(res); - }; - - ZeroMemory(res, sizeof(res)); - - if (strstr(str2 + 1, ".") != NULL) - { - str1 = strstr(str2 + 1, "."); //3 byte - strncpy(res, str2 + 1, (int)((char*)str1 - str2) - 1); - } - else strcpy(res, str2 + 1); - - if (strstr(res, "/") != NULL) - { - CheckMaskBits(res, flCounter); - } - else - { - starterIP[flCounter][2] = atoi(res); - ipsstartfl[flCounter][2] = atoi(res); - ipsendfl[flCounter][2] = atoi(res); - }; - ZeroMemory(res, sizeof(res)); - - if (strstr(str1 + 1, ".") != NULL) - { - str2 = strstr(str1 + 1, "."); //4 byte - strncpy(res, str1 + 1, (int)((char*)str2 - str1) - 1); - } - else strcpy(res, str1 + 1); - - if (strstr(res, "/") != NULL) - { - CheckMaskBits(res, flCounter); - } - else - { - starterIP[flCounter][3] = atoi(res); - ipsstartfl[flCounter][3] = atoi(res); - ipsendfl[flCounter][3] = atoi(res); - }; - - ipsstart[0] = ipsstartfl[flCounter][0]; - ipsstart[1] = ipsstartfl[flCounter][1]; - ipsstart[2] = ipsstartfl[flCounter][2]; - ipsstart[3] = ipsstartfl[flCounter][3]; - - ipsend[0] = ipsendfl[flCounter][0]; - ipsend[1] = ipsendfl[flCounter][1]; - ipsend[2] = ipsendfl[flCounter][2]; - ipsend[3] = ipsendfl[flCounter][3]; - } - else - { - int x; - char des1[64] = { 0 }; - - for (int i = 0; i < 3; i++) //Filling the range-starting ip mass. - { - x = strcspn(gR, "."); - memcpy(des1, gR, x*sizeof(int)); - memset(gR, ' ', x + 1); - ipsstart[i] = atoi(des1); - ZeroMemory(des1, sizeof(des1)); - if (ipsstart[i] > 255) - { - stt->doEmitionRedFoundData("[Error] Incorrect range."); - stt->doEmitionKillSttThread(); - return -1; - }; - }; - - x = strcspn(gR, "-"); - if (strstr(gR, "-") == NULL) - { - stt->doEmitionRedFoundData("[Error] Incorrect range."); - stt->doEmitionKillSttThread(); - return -1; - }; - - memcpy(des1, gR, x); - ipsstart[3] = atoi(des1); - memset(gR, ' ', x + 1); - - if (strstr(gR, ".") == NULL) - { - stt->doEmitionRedFoundData("[Error] Incorrect range."); - stt->doEmitionKillSttThread(); - return -1; - }; - - for (int i = 0; i < 4; i++) //Filling the range-closing ip mass. - { - x = strcspn(gR, "."); - memcpy(des1, gR, x); - memset(gR, ' ', x + 1); - ipsend[i] = atoi(des1); - - if (ipsend[i] > 255) - { - stt->doEmitionRedFoundData("[Error] Incorrect range."); - stt->doEmitionKillSttThread(); - return -1; - }; - }; - - }; - if ((ipsstart[0] > ipsend[0]) - || - ( - (ipsstart[0] >= ipsend[0]) && (ipsstart[1] > ipsend[1]) - ) || - ( - (ipsstart[0] >= ipsend[0]) && (ipsstart[1] >= ipsend[1]) && (ipsstart[2] > ipsend[2]) - ) || - ( - (ipsstart[0] >= ipsend[0]) && (ipsstart[1] >= ipsend[1]) && (ipsstart[2] >= ipsend[2]) && (ipsstart[3] > ipsend[3]) - ) - ) - { - stt->doEmitionRedFoundData("[Error] Incorrect range."); - stt->doEmitionKillSttThread(); - return -1; - }; - - targets = numOfIps(ipsstart, ipsend); - }; -} - -int ParseArgs(int argc, char *argv[]) { - int s = 0; - int indexPorts = 0; - - if (strstr(argv[1], "-f") != NULL) - { - FileLoader(argv[2]); - } - - if (gMode == 0) - { - if (strstr(argv[2], "-") != NULL) - { - strcpy(gRange, argv[2]); - } - else if (strstr(argv[2], "/") != NULL) - { - strcpy(gRange, GetCIDRRangeStr(argv[2])); - } - else - { - strcpy(gRange, argv[2]); - strcat(gRange, "-"); - strcat(gRange, argv[2]); - }; - - strcpy(saveEndIP, gRange); - strcpy(finalIP, strstr(gRange, "-") + 1); - } - else if (gMode == 1) - { - if (strstr(argv[2], "/") != NULL) - { - strcpy(gRange, argv[2]); - strcpy(saveEndIP, argv[2]); - } - else - { - strcpy(gRange, argv[2]); - strcpy(saveEndIP, gRange); - }; - }; - - for (int i = 1; i <= argc - 1; i++) - { - s += strlen(argv[i]) + 2; - }; - - char *argString = new char[s + 1]; - ZeroMemory(argString, sizeof(*argString)); - - for (int i = 1; i <= argc - 1; i++) - { - strcat(argString, argv[i]); - if (i != argc - 1) strcat(argString, "::"); - }; - - if (strstr(argString, "-p") != NULL) - { - char *portString = strstr(argString, "-p"); - char p[4096] = { 0 }; - if (strstr(portString, "::") != NULL) - { - strncpy(gPorts, portString, (int)(strstr(portString, "::") - portString)); - strncpy(p, strstr(argString, "-p") + 2, (int)(strstr(portString, "::") - portString)); - } - else - { - strcpy(gPorts, portString); - strcpy(p, strstr(argString, "-p") + 2); - }; - char *lex; - - if (strstr(p, ",") != NULL) - { - lex = strtok(p, ","); - portArr[indexPorts++] = atoi(lex); - - while ((lex = strtok(NULL, ",")) != NULL) - { - portArr[indexPorts++] = atoi(lex); - overallPorts++; - }; - } - else if (strstr(p, "-") != NULL) - { - char *startp; - char *endp; - char buffForPorts[16] = { 0 }; - - lex = strtok(p, "-p"); - startp = lex; - lex = strtok(NULL, "-"); - endp = lex; - - for (int i = atoi(startp); i <= atoi(endp); i++) - { - portArr[indexPorts++] = i; - overallPorts++; - }; - - ZeroMemory(buffForPorts, sizeof(buffForPorts)); - } - else - { - lex = strtok(p, "-p"); - portArr[indexPorts++] = atoi(lex); - }; - } - else - { - portArr[0] = 80; - portArr[1] = 81; - portArr[2] = 88; - portArr[3] = 8080; - portArr[4] = 8081; - portArr[5] = 60001; - portArr[6] = 60002; - portArr[7] = 8008; - portArr[8] = 8888; - portArr[9] = 554; - portArr[10] = 9000; - portArr[11] = 441; - portArr[12] = 4111; - portArr[13] = 6667; - portArr[14] = 3536; - portArr[15] = 22; - portArr[16] = 21; - - overallPorts = 16; - - strcpy(gPorts, "--DEFAULT"); - }; - - ZeroMemory(argString, sizeof(*argString)); - - delete[] argString; - - return 0; -} - -char charAll[38] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '_', '-', -'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', -'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' }; - -int _getPos(char l) { - for (int i = 0; i < 38; ++i) - { - if (l == charAll[i]) return i; - }; - return -1; -} - -int _getChunkCount(char *data) { - int firstPos = _getPos(data[1]); - int secondPos = _getPos(data[2]); - return secondPos - firstPos + 1; -} - -void _connect() { - - std::string ip = ""; - std::unique_lock lk; - while (globalScanFlag) { - lk = std::unique_lock(Threader::m); - Threader::cv.wait(lk, []{return Threader::ready; }); - - if (!globalScanFlag || Threader::threadId > gThreads) { - --Threader::threadId; - lk.unlock(); - Threader::ready = true; - Threader::cv.notify_all(); - return; - } - - Threader::ready = false; - - if (!Threader::ipQueue.empty()) { - ip = Threader::ipQueue.front(); - Threader::ipQueue.pop(); - lk.unlock(); - - ++ipCounter; - - ++cons; - for (int i = 0; i <= overallPorts; ++i) - { - if (!globalScanFlag) break; - if (Connector::_ConnectToPort((char*)ip.c_str(), portArr[i]) == -2) break; - }; - //if (cons > 0) --cons; - --cons; - stt->doEmitionUpdateArc(gTargets); - } - else lk.unlock(); - } -} - -int _GetDNSFromMask(char *mask, char *saveMask, char *saveMaskEnder) { - - if (strstr(mask, "[") != NULL) - { - char maskEnd[1024] = { 0 }; - char maskRes[1024] = { 0 }; - char *ptr1 = strstr(mask, "["); - char *ptr2 = strstr(ptr1, "]"); - int sz = ptr2 - ptr1; - char chunk[8] = { 0 }; - strncpy(chunk, ptr1, sz + 1); - int firstPos = _getPos(chunk[1]); - int secondPos = _getPos(chunk[2]); - - if (firstPos > secondPos) - { - stt->doEmitionRedFoundData("Error at mask (Wrong letter sequence)"); - return -1; - }; - - char maskStart[1024] = { 0 }; - int startPosition = strstr(mask, "[") - mask; - strncpy(maskStart, mask, startPosition); - - char maskEntry[1024] = { 0 }; - if (saveMaskEnder != NULL) - { - int startSavePosition = strstr(saveMaskEnder, "[") - saveMaskEnder; - strncpy(maskEntry, saveMaskEnder, startSavePosition); - }; - - int szMask = strlen(mask); - int szOffset = startPosition + 2; - if (szMask != szOffset) strcpy(maskEnd, strstr(mask, "]") + 1); - else ZeroMemory(maskEnd, sizeof(maskEnd));; - - char maskSaver[128] = { 0 }; - if (firstPos != -1 && secondPos != -1) - { - for (int i = firstPos; i <= secondPos; ++i) - { - if (!globalScanFlag) break; - - strcpy(maskSaver, saveMask); - strcat(maskSaver, maskEntry); - chunk[1] = charAll[i]; - strcat(maskSaver, chunk); - strcpy(maskRes, maskStart); - maskRes[startPosition] = charAll[i]; - strcat(maskRes, maskEnd); - - if (_GetDNSFromMask(maskRes, maskSaver, maskEnd) == -1) return -1; - - ZeroMemory(maskSaver, sizeof(maskSaver)); - ZeroMemory(maskRes, sizeof(maskRes)); - }; - }; - } - else - { - strcpy(currentMask, saveMask); - while (cons >= gThreads && globalScanFlag) Sleep(300); - if (!globalScanFlag) return 0; - - ++indexIP; - sprintf(currentIP, "%s%s", mask, gTLD); - verboseProgress(gTargets); - - Threader::fireThread(currentIP, (void*(*)(void))_connect); - }; -} - -void runAuxiliaryThreads() { - - FileUpdater::loadOnce(); - if (!FileUpdater::running) { - std::thread lpThread(FileUpdater::updateLists); - lpThread.detach(); - } - if (!trackerRunning) { - std::thread trackerThread(_tracker); - trackerThread.detach(); - } - if (!timerRunning) { - std::thread timerThread(_timer); - timerThread.detach(); - } - if (!saverRunning) { - std::thread saverThread(_saver); - saverThread.detach(); - } -} - - -int startScan(char* args) { - curl_global_init(CURL_GLOBAL_ALL); - - horLineFlag = false; - flCounter = 0; - PieAnomC1 = 0, PieWF = 0, PieBA = 0, PieSusp = 0, PieLowl = 0, PieSSH = 0; - AnomC1 = 0, baCount = 0, Filt = 0, Overl = 0, Lowl = 0, Alive = 0, Activity = 0, saved = 0, Susp = 0, WF = 0, offlines = 0; - BrutingThrds = 0; - found = 0; - gTargets = 0; - targets = 0; - cons = 0; - overallPorts = 0; - found = 0; - indexIP = 0; - - ZeroMemory(octet, sizeof(octet)); - ZeroMemory(ipsstart, sizeof(ipsstart)); - ZeroMemory(ipsend, sizeof(ipsend)); - -#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__) - CreateDirectoryA(RESULT_DIR_NAME, NULL); -#else - struct stat str = {0}; - if (stat(RESULT_DIR_NAME, &str) == -1) { - mkdir(RESULT_DIR_NAME, 0700); - } -#endif - - int argc = 0; - char *argv[512] = { 0 }; - - char *tStr = strtok(args, "|"); - while (tStr != NULL) - { - argv[argc++] = tStr; - tStr = strtok(NULL, "|"); - }; - - ParseArgs(argc, argv); - int resInit = fInit(gMode, gRange); - - if (resInit == -1) - { - stt->doEmitionRedFoundData("[Error] fInit failure"); - stt->doEmitionKillSttThread(); - - return -1; - }; - - globalScanFlag = true; - runAuxiliaryThreads(); - - if (gMode == 0) - { - unsigned long ip1 = (ipsstart[0] * 16777216) + (ipsstart[1] * 65536) + (ipsstart[2] * 256) + ipsstart[3]; - unsigned long ip2 = (ipsend[0] * 16777216) + (ipsend[1] * 65536) + (ipsend[2] * 256) + ipsend[3]; - - switch (gShuffle) { - case true: { - std::vector ipVec; - struct in_addr tAddr; - - for (unsigned long i = ip1; i <= ip2; ++i) { - - if (!globalScanFlag) break; - unsigned long offset = ip2 - i; - - tAddr.s_addr = ntohl(i); - ipVec.push_back(inet_ntoa(tAddr)); - - if (ipVec.size() >= (offset < 1000 ? offset : 1000)) { - - std::random_shuffle(ipVec.begin(), ipVec.end()); - while (ipVec.size() != 0) { - - while (cons >= gThreads && globalScanFlag) Sleep(500); - if (!globalScanFlag) goto haters_gonna_hate_IPM; - - ++indexIP; - strcpy(currentIP, ipVec[0].c_str()); - ipVec.erase(ipVec.begin()); - - verboseProgress(gTargets); - - Threader::fireThread(currentIP, (void*(*)(void))_connect); - } - } - } - - haters_gonna_hate_IPM:; - break; - } - case false: { - struct in_addr tAddr; - for (unsigned long i = ip1; i <= ip2; ++i) { - - while (cons >= gThreads && globalScanFlag) Sleep(500); - if (!globalScanFlag) break; - - ++indexIP; - - tAddr.s_addr = ntohl(i); - strcpy(currentIP, inet_ntoa(tAddr)); - verboseProgress(gTargets); - - Threader::fireThread(currentIP, (void*(*)(void))_connect); - } - break; - } - } - } - else if (gMode == 1) - { - char dataEntry[1024] = { 0 }; - int innerCounter = 0; - int sz = strlen(saveEndIP); - - for (int i = 0; i < sz; ++i) - { - if (saveEndIP[i] == '\\') - { - if (saveEndIP[i + 1] == 'd') - { - strcat(dataEntry, "[09]"); - ++i; - innerCounter += 4; - continue; - } - else if (saveEndIP[i + 1] == 'w') - { - strcat(dataEntry, "[0z]"); - ++i; - innerCounter += 4; - continue; - } - else if (saveEndIP[i + 1] == 'l') - { - strcat(dataEntry, "[az]"); - ++i; - innerCounter += 4; - continue; - } - else - { - QString errStr = "Error at mask (Position:" + QString::number(i + 1); - errStr += ") \""; - errStr += QString(saveEndIP).mid(0, i == 0 ? 0 : i); - errStr += ""; - errStr += QString(saveEndIP).mid(i, i == 0 ? i + 2 : i + 1); - errStr += ""; - errStr += QString(saveEndIP).mid(i + 2, strlen(saveEndIP)); - errStr += "\""; - - stt->doEmitionRedFoundData(errStr); - return -1; - }; - } - else - { - memset(dataEntry + innerCounter++, saveEndIP[i], 1); - }; - }; - - memset(dataEntry + innerCounter + 1, '\0', 1); - strcpy(currentMask, dataEntry); - - for (int i = 0; i < sz; ++i) - { - if (dataEntry[i] == '[') - { - for (int j = i + 1; j < i + 3; ++j) - { - if ((dataEntry[j] < '0' || dataEntry[j] > '9') - && (dataEntry[j] < 'a' || dataEntry[j] > 'z') - && dataEntry[j] != '_' - && dataEntry[j] != '-' - ) - { - QString errStr = "Error at mask (" + QString::number(j - 1); - errStr += ") \""; - errStr += QString(dataEntry).mid(0, j - 1); - errStr += ""; - errStr += QString(dataEntry).mid(j - 1, j + 1); - errStr += ""; - errStr += QString(dataEntry).mid(j + 1, strlen(dataEntry)); - errStr += "\""; - - stt->doEmitionRedFoundData(errStr); - return -1; - }; - }; - i += 3; - } - else if (dataEntry[i] == ']') - { - QString errStr = "Error at mask (" + QString::number(i - 1); - errStr += ") \""; - errStr += QString(dataEntry).mid(0, i - 1); - errStr += ""; - errStr += QString(dataEntry).mid(i - 1, i + 1); - errStr += ""; - errStr += QString(dataEntry).mid(i + 1, strlen(dataEntry)); - errStr += "\""; - - stt->doEmitionRedFoundData(errStr); - return -1; - }; - }; - - unsigned long long dnsCounter = 1; - char *dnsPtr1 = strstr(dataEntry, "["); - while (dnsPtr1 != NULL) - { - dnsCounter *= _getChunkCount(dnsPtr1); - dnsPtr1 = strstr(dnsPtr1 + 1, "["); - }; - - gTargets = dnsCounter; - gTargetsOverall = gTargets; - stt->doEmitionYellowFoundData("Starting DNS-scan..."); - stt->doEmitionChangeStatus("Scanning..."); - - int y = _GetDNSFromMask(dataEntry, "", dataEntry); - if (y == -1) - { - stt->doEmitionRedFoundData("DNS-Mode error"); - }; - } - else if (gMode == -1) - { - if (flCounter == 0) - { - stt->doEmitionRedFoundData("Empty IP list."); - globalScanFlag = false; - stt->doEmitionKillSttThread(); - - return -1; - }; - - stt->doEmitionChangeStatus("Scanning..."); - for (gC = 0; gC < flCounter; ++gC) - { - strcpy(metaRange, std::to_string(ipsstartfl[gC][0]).c_str()); - strcat(metaRange, "."); - strcat(metaRange, std::to_string(ipsstartfl[gC][1]).c_str()); - strcat(metaRange, "."); - strcat(metaRange, std::to_string(ipsstartfl[gC][2]).c_str()); - strcat(metaRange, "."); - strcat(metaRange, std::to_string(ipsstartfl[gC][3]).c_str()); - strcat(metaRange, "-"); - strcat(metaRange, std::to_string(ipsendfl[gC][0]).c_str()); - strcat(metaRange, "."); - strcat(metaRange, std::to_string(ipsendfl[gC][1]).c_str()); - strcat(metaRange, "."); - strcat(metaRange, std::to_string(ipsendfl[gC][2]).c_str()); - strcat(metaRange, "."); - strcat(metaRange, std::to_string(ipsendfl[gC][3]).c_str()); - - unsigned long ip1 = (ipsstartfl[gC][0] * 16777216) + (ipsstartfl[gC][1] * 65536) + (ipsstartfl[gC][2] * 256) + ipsstartfl[gC][3]; - unsigned long ip2 = (ipsendfl[gC][0] * 16777216) + (ipsendfl[gC][1] * 65536) + (ipsendfl[gC][2] * 256) + ipsendfl[gC][3]; - - switch (gShuffle) { - case true: { - std::vector ipVec; - struct in_addr tAddr; - - for (unsigned long i = ip1; i <= ip2; ++i) { - - if (!globalScanFlag) break; - unsigned long offset = ip2 - i; - - tAddr.s_addr = ntohl(i); - ipVec.push_back(inet_ntoa(tAddr)); - - if (ipVec.size() >= (offset < 1000 ? offset : 1000)) { - - std::random_shuffle(ipVec.begin(), ipVec.end()); - while (ipVec.size() != 0) { - - while (cons >= gThreads && globalScanFlag) Sleep(500); - if (!globalScanFlag) goto haters_gonna_hate_IM; - - ++indexIP; - strcpy(currentIP, ipVec[0].c_str()); - ipVec.erase(ipVec.begin()); - verboseProgress(gTargets); - - Threader::fireThread(currentIP, (void*(*)(void))_connect); - } - } - } - haters_gonna_hate_IM:; - break; - } - case false: { - struct in_addr tAddr; - for (unsigned long i = ip1; i <= ip2; ++i) { - - while (cons >= gThreads && globalScanFlag) Sleep(500); - if (!globalScanFlag) break; - - ++indexIP; - - tAddr.s_addr = ntohl(i); - strcpy(currentIP, inet_ntoa(tAddr)); - verboseProgress(gTargets); - Threader::fireThread(currentIP, (void*(*)(void))_connect); - } - break; - }; - } - } - } - else - { - stt->doEmitionRedFoundData("Wrong parameters."); - }; - - Sleep(gTimeOut + 1); - - stt->doEmitionYellowFoundData("Stopping threads..."); - stt->doEmitionChangeStatus("Stopping..."); - - while (cons > 0 || jsonArr->size() > 0) { - Sleep(2000); - }; - - stt->doEmitionGreenFoundData("Done. Saved: " + QString::number(saved) + "; Alive: " + QString::number(found) + "."); - stt->doEmitionChangeStatus("Idle"); - - nCleanup(); - stt->doEmitionKillSttThread(); -} - -void nCleanup(){ - FileUpdater::FUClear(); - Threader::cleanUp(); - curl_global_cleanup(); - - while (__savingBackUpFile) Sleep(100); - - if (loginLst != NULL) - { - for (int i = 0; i < MaxLogin; ++i) delete[]loginLst[i]; - delete[]loginLst; - loginLst = NULL; - }; - if (passLst != NULL) - { - for (int i = 0; i < MaxPass; ++i) delete[]passLst[i]; - delete[]passLst; - passLst = NULL; - }; - if (GlobalNegatives != NULL) - { - for (int i = 0; i < GlobalNegativeSize; ++i) delete[]GlobalNegatives[i]; - delete[]GlobalNegatives; - GlobalNegatives = NULL; - }; - if (wfPassLst != NULL) - { - for (int i = 0; i < MaxWFPass; ++i) delete[]wfPassLst[i]; - delete[]wfPassLst; - wfPassLst = NULL; - }; - if (wfLoginLst != NULL) - { - for (int i = 0; i < MaxWFLogin; ++i) delete[]wfLoginLst[i]; - delete[]wfLoginLst; - wfLoginLst = NULL; - }; - if (sshlpLst != NULL) - { - for (int i = 0; i < MaxSSHPass; ++i) delete[]sshlpLst[i]; - delete[]sshlpLst; - sshlpLst = NULL; - }; - if (ipsstartfl != NULL) - { - for (int i = 0; i < flCounter; ++i) delete[]ipsstartfl[i]; - delete[]ipsstartfl; - ipsstartfl = NULL; - }; - if (ipsendfl != NULL) - { - for (int i = 0; i < flCounter; ++i) delete[]ipsendfl[i]; - delete[]ipsendfl; - ipsendfl = NULL; - }; - if (starterIP != NULL) - { - for (int i = 0; i < flCounter; ++i) delete[]starterIP[i]; - delete[]starterIP; - starterIP = NULL; - }; -} diff --git a/progressbardrawer.cpp b/progressbardrawer.cpp index 2496287..15d879a 100644 --- a/progressbardrawer.cpp +++ b/progressbardrawer.cpp @@ -12,7 +12,7 @@ void ProgressbarDrawer::run() while(globalScanFlag) { msleep(1000); - nesca_3::perc = (unsigned long)100*indexIP/(gTargetsOverall == 0 ? 1 : gTargetsOverall); + nesca_3::perc = (unsigned long)100*indexIP/(gTargetsNumber == 0 ? 1 : gTargetsNumber); update(); }; }; \ No newline at end of file diff --git a/version b/version index d440389..47872bc 100644 --- a/version +++ b/version @@ -1 +1 @@ -24B85-51F \ No newline at end of file +24B8E-5B2 \ No newline at end of file