2015-04-14 11:58:33 +00:00
|
|
|
#include "MainStarter.h"
|
2015-04-16 11:51:51 +00:00
|
|
|
|
|
|
|
int gTimeOut = 3;
|
|
|
|
int gPingTimeout = 1;
|
|
|
|
int gMode;
|
2015-08-07 22:37:28 +00:00
|
|
|
int PieCamerasC1 = 0, PieBA = 0, PieOther = 0, PieSSH = 0;
|
|
|
|
int camerasC1 = 0, filtered = 0, Overl = 0, Alive = 0, saved = 0, other = 0, ssh = 0;
|
2015-04-16 11:51:51 +00:00
|
|
|
int found = 0, indexIP = 0;
|
2015-08-07 22:37:28 +00:00
|
|
|
int MaxPass = 0, MaxLogin = 0,
|
|
|
|
MaxWFLogin = 0, MaxWFPass = 0,
|
|
|
|
MaxFTPLogin = 0, MaxFTPPass = 0,
|
|
|
|
MaxSSHPass = 0;
|
2015-04-16 11:51:51 +00:00
|
|
|
int baCount = 0;
|
|
|
|
int gMaxBrutingThreads = 50;
|
|
|
|
unsigned int Activity = 0;
|
|
|
|
char gTLD[128] = { 0 };
|
|
|
|
char gPorts[65536] = { 0 };
|
|
|
|
char currentIP[MAX_ADDR_LEN] = { 0 };
|
|
|
|
char finalIP[32] = { 0 };
|
|
|
|
bool gPingNScan = false;
|
2016-01-06 20:40:43 +00:00
|
|
|
std::atomic<int> cons(0), BrutingThrds(0), gThreads(0);
|
|
|
|
std::vector<int> MainStarter::portVector(0);
|
2015-04-14 11:58:33 +00:00
|
|
|
int MainStarter::flCounter = 0;
|
2015-08-22 20:55:40 +00:00
|
|
|
int MainStarter::gflIndex = 0;
|
|
|
|
unsigned int **MainStarter::ipsstartfl = NULL;
|
|
|
|
unsigned int **MainStarter::ipsendfl = NULL;
|
2015-04-16 11:51:51 +00:00
|
|
|
bool MainStarter::savingBackUpFile = false;
|
2015-04-14 11:58:33 +00:00
|
|
|
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 };
|
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
bool saveBackup;
|
|
|
|
|
2015-04-23 05:23:02 +00:00
|
|
|
void MainStarter::unBlockButtons(){
|
|
|
|
stt->doEmitionBlockButton(false);
|
|
|
|
}
|
2015-04-18 22:30:55 +00:00
|
|
|
int MainStarter::fileLoader(const char *fileName) {
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
unsigned int importFileSize = 0;
|
|
|
|
|
|
|
|
FILE *fl = fopen(fileName, "r");
|
|
|
|
if (fl != NULL)
|
|
|
|
{
|
2015-08-07 22:37:28 +00:00
|
|
|
char curIP[256] = { 0 };
|
2015-04-14 11:58:33 +00:00
|
|
|
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)
|
2015-04-18 22:30:55 +00:00
|
|
|
&& (curIP[0] == '\t' && curIP[1] == '\t' && curIP[2] == '\t' && (curIP[3] == '/' && curIP[4] == '/')) == false
|
|
|
|
) ++importFileSize;
|
2015-12-08 16:53:54 +00:00
|
|
|
curIP[0] = 0;
|
|
|
|
//ZeroMemory(curIP, sizeof(curIP));
|
2015-04-14 11:58:33 +00:00
|
|
|
};
|
2015-08-07 22:37:28 +00:00
|
|
|
fclose(fl);
|
|
|
|
}
|
|
|
|
else stt->doEmitionRedFoundData("[IP Loader] Cannot open IP list.");
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
if (importFileSize == 0) return -1;
|
2015-04-18 22:30:55 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
ipsstartfl = new unsigned int*[importFileSize + 1];
|
|
|
|
ipsendfl = new unsigned int*[importFileSize + 1];
|
2015-12-11 10:51:03 +00:00
|
|
|
//ipsstartfl[0] = 0;
|
|
|
|
//ipsendfl[0] = 0;
|
2015-12-08 16:53:54 +00:00
|
|
|
/*ZeroMemory(ipsstartfl, sizeof(ipsstartfl));
|
|
|
|
ZeroMemory(ipsendfl, sizeof(ipsendfl));*/
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
for (int i = 0; i < importFileSize; ++i)
|
|
|
|
{
|
|
|
|
ipsstartfl[i] = new unsigned int[4];
|
|
|
|
ipsendfl[i] = new unsigned int[4];
|
2015-04-18 22:30:55 +00:00
|
|
|
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(ipsstartfl[i], sizeof(ipsstartfl[i]));
|
|
|
|
//ZeroMemory(ipsendfl[i], sizeof(ipsendfl[i]));
|
2015-12-11 10:51:03 +00:00
|
|
|
//ipsstartfl[i] = 0;
|
|
|
|
//ipsendfl[i] = 0;
|
2015-08-07 22:37:28 +00:00
|
|
|
};
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
std::vector<std::string> shuffleArray;
|
|
|
|
ifstream inputStream(fileName);
|
|
|
|
std::string curIPStr;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
while (!inputStream.eof())
|
|
|
|
{
|
|
|
|
std::getline(inputStream, curIPStr);
|
|
|
|
if (curIPStr.size() > 1
|
|
|
|
&& curIPStr.find("#") == std::string::npos) shuffleArray.push_back(curIPStr);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::random_shuffle(shuffleArray.begin(), shuffleArray.end());
|
|
|
|
for (int i = 0; i < importFileSize; ++i) {
|
|
|
|
curIPStr = shuffleArray[i];
|
|
|
|
if (curIPStr.find("-") != std::string::npos) {
|
|
|
|
std::vector<std::string> tmpIPVec = Utils::splitToStrVector(curIPStr, '-');
|
|
|
|
std::vector<int> tmpIPIntVec1 = Utils::splitToIntVector(tmpIPVec[0], '.');
|
|
|
|
std::vector<int> tmpIPIntVec2 = Utils::splitToIntVector(tmpIPVec[1], '.');
|
|
|
|
|
|
|
|
ipsstartfl[MainStarter::flCounter][0] = tmpIPIntVec1[0];
|
|
|
|
ipsstartfl[MainStarter::flCounter][1] = tmpIPIntVec1[1];
|
|
|
|
ipsstartfl[MainStarter::flCounter][2] = tmpIPIntVec1[2];
|
|
|
|
ipsstartfl[MainStarter::flCounter][3] = tmpIPIntVec1[3];
|
|
|
|
|
|
|
|
ipsendfl[MainStarter::flCounter][0] = tmpIPIntVec2[0];
|
|
|
|
ipsendfl[MainStarter::flCounter][1] = tmpIPIntVec2[1];
|
|
|
|
ipsendfl[MainStarter::flCounter][2] = tmpIPIntVec2[2];
|
|
|
|
ipsendfl[MainStarter::flCounter][3] = tmpIPIntVec2[3];
|
|
|
|
|
|
|
|
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]
|
|
|
|
)
|
|
|
|
)
|
2015-04-14 11:58:33 +00:00
|
|
|
{
|
2015-08-07 22:37:28 +00:00
|
|
|
stt->doEmitionRedFoundData(" [IP Loader]Wrong list format. String-> [" +
|
|
|
|
QString(curIPStr.c_str()) + "]");
|
|
|
|
return -1;
|
|
|
|
};
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
unsigned long ip1 = (ipsstartfl[MainStarter::flCounter][0] * 16777216) +
|
|
|
|
(ipsstartfl[MainStarter::flCounter][1] * 65536) +
|
|
|
|
(ipsstartfl[MainStarter::flCounter][2] * 256) +
|
|
|
|
ipsstartfl[MainStarter::flCounter][3];
|
|
|
|
unsigned long ip2 = (ipsendfl[MainStarter::flCounter][0] * 16777216) +
|
|
|
|
(ipsendfl[MainStarter::flCounter][1] * 65536) +
|
|
|
|
(ipsendfl[MainStarter::flCounter][2] * 256) +
|
|
|
|
ipsendfl[MainStarter::flCounter][3];
|
|
|
|
|
|
|
|
if (ip1 > ip2) {
|
|
|
|
stt->doEmitionRedFoundData(" Malformed input: check your range (" +
|
|
|
|
QString(curIPStr.c_str()) + ")");
|
|
|
|
}
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
gTargets += ip2 - ip1 + 1;
|
|
|
|
++MainStarter::flCounter;
|
|
|
|
}
|
|
|
|
else if (curIPStr.find("/") != std::string::npos)
|
|
|
|
{
|
|
|
|
if (curIPStr.size() > 18) {
|
|
|
|
stt->doEmitionRedFoundData(" [IP Loader]Wrong list format. String-> [" +
|
|
|
|
QString(curIPStr.c_str()) +
|
|
|
|
"]");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
unsigned int ip[4] = { 0 }, ip_min[4] = { 0 }, ip_max[4] = { 0 }, tmp1, tmp2;
|
|
|
|
unsigned int netmask = atoi(strstr(curIPStr.c_str(), "/") + 1);
|
2015-04-18 14:20:52 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
std::vector<int> tmpIPVec = Utils::splitToIntVector(curIPStr.c_str(), '.');
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
for (int i = 0; i < tmpIPVec.size(); ++i) ip[i] = tmpIPVec[i];
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
/*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;
|
|
|
|
}
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
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];
|
|
|
|
|
|
|
|
if (ip1 > ip2) {
|
|
|
|
stt->doEmitionRedFoundData("Malformed input: check your range (" +
|
|
|
|
QString(curIPStr.c_str()) + ")");
|
|
|
|
}
|
2015-04-18 14:20:52 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
gTargets += ip2 - ip1 + 1;
|
|
|
|
++MainStarter::flCounter;
|
|
|
|
}
|
|
|
|
else if (strstr(curIPStr.c_str(), "RESTORE_IMPORT_SESSION") != NULL)
|
|
|
|
{
|
|
|
|
///DUMMY///
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
stt->doEmitionRedFoundData("[IP Loader]Wrong list format. Line-> [" +
|
|
|
|
QString::number(MainStarter::flCounter) +
|
|
|
|
"] String-> [" +
|
|
|
|
QString(curIPStr.c_str()) +
|
|
|
|
"]");
|
|
|
|
return -1;
|
2015-04-14 11:58:33 +00:00
|
|
|
};
|
2015-08-07 22:37:28 +00:00
|
|
|
};
|
|
|
|
gTargetsNumber = gTargets;
|
|
|
|
stt->doEmitionYellowFoundData("List loader - [OK] (" + QString::number(gTargetsNumber + 1) + " hosts)");
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
int MainStarter::loadTargets(const char *data) {
|
|
|
|
|
|
|
|
if (gMode == 0) {
|
|
|
|
std::vector<std::string> 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);
|
|
|
|
|
2015-04-19 12:13:02 +00:00
|
|
|
std::vector<int> tmpIPVec = Utils::splitToIntVector(data, '.');
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
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]);
|
2015-04-19 12:13:02 +00:00
|
|
|
rangeVec = Utils::splitToStrVector(std::string(newRangeString), '-');
|
2015-04-14 11:58:33 +00:00
|
|
|
}
|
2015-04-19 12:13:02 +00:00
|
|
|
else rangeVec = Utils::splitToStrVector(data, '-');
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-04-19 12:13:02 +00:00
|
|
|
std::vector<int> ip1TmpVec = Utils::splitToIntVector(rangeVec[0], '.');
|
|
|
|
std::vector<int> ip2TmpVec = Utils::splitToIntVector(rangeVec[1], '.');
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
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];
|
2015-04-18 14:20:52 +00:00
|
|
|
|
|
|
|
if (ip1 > ip2) {
|
|
|
|
stt->doEmitionRedFoundData("Malformed input: check your range");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-04-14 11:58:33 +00:00
|
|
|
sprintf(finalIP, "%d.%d.%d.%d",
|
|
|
|
ipsend[0], ipsend[1], ipsend[2], ipsend[3]);
|
2015-04-18 14:20:52 +00:00
|
|
|
|
|
|
|
gTargets = ip2 - ip1 + 1;
|
|
|
|
gTargetsNumber = gTargets;
|
2015-04-14 11:58:33 +00:00
|
|
|
}
|
|
|
|
else if (gMode == 1) {
|
|
|
|
strncpy(dnsTarget, data, 256);
|
2015-04-18 14:20:52 +00:00
|
|
|
|
|
|
|
gTargets = ip2 - ip1 + 1;
|
|
|
|
gTargetsNumber = gTargets;
|
2015-04-14 11:58:33 +00:00
|
|
|
}
|
|
|
|
else {
|
2015-04-18 22:30:55 +00:00
|
|
|
if (fileLoader(data) == -1) {
|
|
|
|
stt->doEmitionRedFoundData("IP list is empty.");
|
|
|
|
return -1;
|
|
|
|
}
|
2015-04-18 14:20:52 +00:00
|
|
|
sprintf(finalIP, "%d.%d.%d.%d",
|
|
|
|
ipsendfl[gflIndex][0], ipsendfl[gflIndex][1], ipsendfl[gflIndex][2], ipsendfl[gflIndex][3]);
|
2015-04-14 11:58:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
int MainStarter::loadPorts(const char *data, char delim) {
|
2015-04-19 12:13:02 +00:00
|
|
|
portVector = Utils::splitToIntVector(data, delim);
|
2015-04-14 11:58:33 +00:00
|
|
|
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",
|
2016-01-06 20:40:43 +00:00
|
|
|
gMode, endStr, gTLD, int(gThreads), gPorts);
|
2015-04-14 11:58:33 +00:00
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
else if (gMode == -1)
|
|
|
|
{
|
|
|
|
char ipRange[128] = { 0 };
|
|
|
|
|
|
|
|
if (MainStarter::flCounter > 0)
|
|
|
|
{
|
2015-08-07 22:37:28 +00:00
|
|
|
if (!saveBackup) return;
|
2015-04-14 11:58:33 +00:00
|
|
|
FILE *savingFile = fopen("tempIPLst.bk", "w");
|
2015-08-22 20:55:40 +00:00
|
|
|
if (NULL != savingFile)
|
2015-04-14 11:58:33 +00:00
|
|
|
{
|
2015-04-20 19:27:06 +00:00
|
|
|
if (gflIndex < MainStarter::flCounter) {
|
2015-08-07 22:37:28 +00:00
|
|
|
sprintf(ipRange, "%d.%d.%d.%d-%d.%d.%d.%d\n",
|
|
|
|
ipsstartfl[gflIndex][0],
|
|
|
|
ipsstartfl[gflIndex][1],
|
|
|
|
ipsstartfl[gflIndex][2],
|
|
|
|
ipsstartfl[gflIndex][3],
|
2015-04-20 19:27:06 +00:00
|
|
|
ipsendfl[gflIndex][0],
|
|
|
|
ipsendfl[gflIndex][1],
|
|
|
|
ipsendfl[gflIndex][2],
|
|
|
|
ipsendfl[gflIndex][3]);
|
|
|
|
fputs(ipRange, savingFile);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(ipRange, sizeof(ipRange));
|
|
|
|
ipRange[0] = 0;
|
2015-04-20 19:27:06 +00:00
|
|
|
}
|
2015-04-14 11:58:33 +00:00
|
|
|
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);
|
|
|
|
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(ipRange, sizeof(ipRange));
|
|
|
|
ipRange[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
};
|
|
|
|
fclose(savingFile);
|
|
|
|
}
|
|
|
|
else stt->doEmitionRedFoundData("[_saver] Cannot open file.");
|
|
|
|
};
|
|
|
|
|
2016-01-06 20:40:43 +00:00
|
|
|
sprintf(saveStr, "[SESSION]:%d RESTORE_IMPORT_SESSION %d %s\n", gMode, int(gThreads), gPorts);
|
2015-04-14 11:58:33 +00:00
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-05-01 15:30:14 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
sprintf(saveStr, "[SESSION]: 0 1.1.1.1/32 0 -p80");
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-05-01 15:30:14 +00:00
|
|
|
}
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[NDBSERVER]:%s\n", trcSrv);
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[NDBSCRIPT]:%s\n", trcScr);
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[NDBPORT]:%s\n", trcSrvPortLine);
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[PROXY]:%s\n", trcProxy);
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[PROXYPORT]:%s\n", trcPort);
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[PING]:%s\n", gPingNScan ? "true" : "false");
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[SHUFFLE]:%s\n", gShuffle ? "true" : "false");
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[NSTRACK]:%s\n", trackerOK ? "true" : "false");
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[PING_TO]: %d\n", gPingTimeout);
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-04-16 11:51:51 +00:00
|
|
|
sprintf(saveStr, "[THREAD_DELAY]: %d\n", Threader::gThreadDelay);
|
2015-04-14 11:58:33 +00:00
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[TIMEOUT]: %d\n", gTimeOut);
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[MAXBTHR]: %d\n", gMaxBrutingThreads);
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[SYSTEMPROXYIP]: %s\n", gProxyIP);
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
sprintf(saveStr, "[SYSTEMPROXYPORT]: %s\n", gProxyPort);
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
strcpy(saveStr, "[PERSKEY]:");
|
|
|
|
strncat(saveStr, trcPersKey, 32);
|
|
|
|
strcat(saveStr, "\n");
|
|
|
|
strcat(saveBuffer, saveStr);
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveStr, sizeof(saveStr));
|
|
|
|
saveStr[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-04-16 11:51:51 +00:00
|
|
|
std::string finalSaveStr(saveBuffer);
|
|
|
|
std::ofstream file("restore");
|
2015-04-20 19:27:06 +00:00
|
|
|
if (finalSaveStr.size() > 0) file << finalSaveStr;
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(saveBuffer, sizeof(saveBuffer));
|
|
|
|
saveBuffer[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool saverRunning = false;
|
2015-08-22 20:55:40 +00:00
|
|
|
void MainStarter::saveBK() {
|
|
|
|
while (savingBackUpFile) Sleep(400);
|
|
|
|
savingBackUpFile = true;
|
|
|
|
saveBackupToFile();
|
|
|
|
savingBackUpFile = false;
|
|
|
|
}
|
2015-04-14 11:58:33 +00:00
|
|
|
void MainStarter::saver()
|
|
|
|
{
|
|
|
|
saverRunning = true;
|
|
|
|
Sleep(1000);
|
2015-08-07 22:37:28 +00:00
|
|
|
while (saveBackup && globalScanFlag)
|
2015-04-14 11:58:33 +00:00
|
|
|
{
|
2015-08-22 20:55:40 +00:00
|
|
|
saveBK();
|
2015-04-14 11:58:33 +00:00
|
|
|
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];
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(msg, sizeof(*msg));
|
|
|
|
msg[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(rBuffT, sizeof(rBuffT));
|
|
|
|
rBuffT[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(rBuffT, sizeof(rBuffT));
|
|
|
|
rBuffT[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
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)));
|
2015-04-16 11:51:51 +00:00
|
|
|
jsonMeta.insert("bads", QJsonValue("-1"));
|
2015-04-14 11:58:33 +00:00
|
|
|
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];
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(msg, sizeof(*msg));
|
|
|
|
msg[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
2015-04-16 11:51:51 +00:00
|
|
|
stt->doEmitionRedFoundData("[NS-Track] connect() returned " +
|
|
|
|
QString::number(WSAGetLastError()) + ".");
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2015-04-16 11:51:51 +00:00
|
|
|
stt->doEmitionRedFoundData("[NS-Track] send() returned " +
|
|
|
|
QString::number(WSAGetLastError()) + ".");
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
continue;
|
|
|
|
};
|
|
|
|
|
2015-12-08 16:53:54 +00:00
|
|
|
//ZeroMemory(rBuffT, sizeof(rBuffT));
|
|
|
|
rBuffT[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
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)
|
|
|
|
{
|
2015-04-16 11:51:51 +00:00
|
|
|
stt->doEmitionRedFoundData("[NS-Track] (Inner) Large error received from server (>200000b) " +
|
2015-04-14 11:58:33 +00:00
|
|
|
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);
|
|
|
|
|
2015-04-16 11:51:51 +00:00
|
|
|
stt->doEmitionRedFoundData("[NS-Track] recv() returned " + QString::number(WSAGetLastError()) + ".");
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
continue;
|
|
|
|
};
|
|
|
|
|
|
|
|
if (strstr(rBuffT, "201 Created") != NULL)
|
|
|
|
{
|
|
|
|
|
2015-04-16 11:51:51 +00:00
|
|
|
if (gDebugMode) stt->doEmitionYellowFoundData("[NS-Track] OK. Data saved!");
|
2015-04-14 11:58:33 +00:00
|
|
|
stt->doEmitionDataSaved(true);
|
|
|
|
Sleep(1000);
|
|
|
|
stt->doEmitionDataSaved(false);
|
|
|
|
|
|
|
|
}
|
|
|
|
else if (strstr(rBuffT, "400 Bad Request") != NULL)
|
|
|
|
{
|
2015-04-16 11:51:51 +00:00
|
|
|
QString errorDef = Utils::GetNSErrorDefinition(rBuffT, "notify");
|
2015-04-14 11:58:33 +00:00
|
|
|
if (errorDef == "Invalid access key") stt->doEmitionYellowFoundData("[NS-Track] [Key is unauthorized] A valid key is required.");
|
2015-04-16 11:51:51 +00:00
|
|
|
else stt->doEmitionYellowFoundData("[NS-Track] FAIL! [400 Bad Request : " + errorDef + "]");
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-04-16 11:51:51 +00:00
|
|
|
stt->doEmitionYellowFoundData("[NS-Track] FAIL! An error occured [" + QString(msgR) + "]");
|
2015-04-14 11:58:33 +00:00
|
|
|
};
|
|
|
|
|
2015-12-08 16:53:54 +00:00
|
|
|
msgR[0] = 0;
|
|
|
|
rBuffT[0] = 0;
|
|
|
|
msg[0] = 0;
|
|
|
|
/*ZeroMemory(msgR, sizeof(msgR));
|
2015-04-14 11:58:33 +00:00
|
|
|
ZeroMemory(rBuffT, sizeof(rBuffT));
|
2015-12-08 16:53:54 +00:00
|
|
|
ZeroMemory(msg, sizeof(*msg));*/
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
if (msg != NULL)
|
|
|
|
{
|
|
|
|
delete msg;
|
|
|
|
msg = NULL;
|
|
|
|
};
|
|
|
|
|
|
|
|
CSSOCKET(sock);
|
|
|
|
};
|
|
|
|
Sleep(10000);
|
|
|
|
};
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-04-16 11:51:51 +00:00
|
|
|
stt->doEmitionRedFoundData("[NS-Track] Balancer replied with invalid string.");
|
2015-04-14 11:58:33 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
2016-11-23 02:38:47 +00:00
|
|
|
sprintf(targetNPers, "%lu (%.1f%%)", target, percent);
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2016-11-23 02:38:47 +00:00
|
|
|
sprintf(metaTargets, "%lu", target);
|
2015-04-14 11:58:33 +00:00
|
|
|
sprintf(metaPercent, "%.1f",
|
|
|
|
percent);
|
|
|
|
}
|
|
|
|
|
|
|
|
void _connect() {
|
|
|
|
|
|
|
|
std::string ip = "";
|
|
|
|
std::unique_lock<std::mutex> lk;
|
|
|
|
while (globalScanFlag) {
|
|
|
|
lk = std::unique_lock<std::mutex>(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;
|
2015-04-28 23:27:54 +00:00
|
|
|
Connector con;
|
2015-04-14 11:58:33 +00:00
|
|
|
for (int i = 0; i < MainStarter::portVector.size(); ++i)
|
|
|
|
{
|
|
|
|
if (!globalScanFlag) break;
|
2015-04-28 23:27:54 +00:00
|
|
|
if (con.connectToPort((char*)ip.c_str(), MainStarter::portVector[i]) == -2) break;
|
2015-04-14 11:58:33 +00:00
|
|
|
};
|
|
|
|
--cons;
|
|
|
|
stt->doEmitionUpdateArc(gTargets);
|
|
|
|
}
|
|
|
|
else lk.unlock();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void MainStarter::startIPScan(){
|
|
|
|
|
|
|
|
switch (gShuffle) {
|
|
|
|
case true: {
|
|
|
|
std::vector<std::string> ipVec;
|
|
|
|
struct in_addr tAddr;
|
|
|
|
|
2015-12-08 16:53:54 +00:00
|
|
|
unsigned long offset = ip2 - ip1;
|
|
|
|
unsigned int limit = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-12-08 16:53:54 +00:00
|
|
|
if (0 == offset) {
|
|
|
|
tAddr.s_addr = ntohl(ip1);
|
2015-04-14 11:58:33 +00:00
|
|
|
ipVec.push_back(inet_ntoa(tAddr));
|
2015-12-08 16:53:54 +00:00
|
|
|
++indexIP;
|
|
|
|
|
|
|
|
strcpy(currentIP, ipVec[0].c_str());
|
|
|
|
ipVec.erase(ipVec.begin());
|
|
|
|
verboseProgress(gTargets);
|
|
|
|
|
|
|
|
Threader::fireThread(currentIP, (void*(*)(void))_connect);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (offset < 1000) {
|
|
|
|
limit = 1;
|
|
|
|
}
|
|
|
|
else if (offset < 10000){
|
|
|
|
limit = 10;
|
|
|
|
}
|
|
|
|
else if (offset < 100000){
|
|
|
|
limit = 100;
|
|
|
|
}
|
|
|
|
else if (offset < 1000000){
|
|
|
|
limit = 1000;
|
|
|
|
}
|
|
|
|
else if (offset < 10000000){
|
|
|
|
limit = 10001;
|
|
|
|
}
|
|
|
|
else if (offset < 100000000){
|
|
|
|
limit = 100011;
|
|
|
|
}
|
|
|
|
else if (offset < 5000000000){
|
|
|
|
limit = 1000111;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long long int firstLoopLimit = (limit == 1 ? ip1 : ip1 + (long long)limit);
|
|
|
|
|
|
|
|
for (unsigned long i = ip1; i <= firstLoopLimit; ++i) {
|
|
|
|
if (!globalScanFlag) break;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-12-08 16:53:54 +00:00
|
|
|
unsigned long long curIP = i;
|
|
|
|
while (curIP <= ip2) {
|
2018-08-17 11:50:53 +00:00
|
|
|
tAddr.s_addr = ntohl(curIP);
|
2015-12-08 16:53:54 +00:00
|
|
|
ipVec.push_back(inet_ntoa(tAddr));
|
2018-08-17 11:50:53 +00:00
|
|
|
curIP += (long long)limit;
|
2015-12-08 16:53:54 +00:00
|
|
|
}
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
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;
|
2015-08-07 22:37:28 +00:00
|
|
|
|
2015-04-14 11:58:33 +00:00
|
|
|
strcpy(currentIP, ipVec[0].c_str());
|
|
|
|
ipVec.erase(ipVec.begin());
|
|
|
|
verboseProgress(gTargets);
|
|
|
|
|
|
|
|
Threader::fireThread(currentIP, (void*(*)(void))_connect);
|
|
|
|
}
|
2015-12-08 16:53:54 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*tAddr.s_addr = ntohl(i);
|
|
|
|
ipVec.push_back(inet_ntoa(tAddr));
|
|
|
|
|
|
|
|
if (ipVec.size() >= (offset < 10000 ? offset : 10000)) {
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}*/
|
2015-04-14 11:58:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2015-12-08 16:53:54 +00:00
|
|
|
else maskEnd[0] = 0;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
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];
|
2016-11-23 02:38:47 +00:00
|
|
|
//strcat(maskSaver, chunk);
|
2015-04-14 11:58:33 +00:00
|
|
|
strcpy(maskRes, maskStart);
|
|
|
|
maskRes[startPosition] = charAll[i];
|
2016-11-23 02:38:47 +00:00
|
|
|
maskRes[startPosition + 1] = '\0';
|
2015-04-14 11:58:33 +00:00
|
|
|
strcat(maskRes, maskEnd);
|
|
|
|
|
2016-11-23 02:38:47 +00:00
|
|
|
if (_GetDNSFromMask(maskRes, maskSaver, NULL) == -1) return -1;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-12-08 16:53:54 +00:00
|
|
|
maskSaver[0] = 0;
|
|
|
|
maskRes[0] = 0;
|
|
|
|
/*ZeroMemory(maskSaver, sizeof(maskSaver));
|
|
|
|
ZeroMemory(maskRes, sizeof(maskRes));*/
|
2015-04-14 11:58:33 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
}
|
|
|
|
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 += "<u>";
|
|
|
|
errStr += QString(dnsTarget).mid(i, i == 0 ? i + 2 : i + 1);
|
|
|
|
errStr += "</u>";
|
|
|
|
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 += "<u>";
|
|
|
|
errStr += QString(dataEntry).mid(j - 1, j + 1);
|
|
|
|
errStr += "</u>";
|
|
|
|
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 += "<u>";
|
|
|
|
errStr += QString(dataEntry).mid(i - 1, i + 1);
|
|
|
|
errStr += "</u>";
|
|
|
|
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...");
|
|
|
|
|
2016-11-23 02:38:47 +00:00
|
|
|
int y = _GetDNSFromMask(dataEntry, "", NULL);
|
2015-04-14 11:58:33 +00:00
|
|
|
if (y == -1)
|
|
|
|
{
|
|
|
|
stt->doEmitionRedFoundData("DNS-Mode error");
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
void MainStarter::startImportScan(){
|
2015-08-09 11:22:02 +00:00
|
|
|
|
2015-04-14 11:58:33 +00:00
|
|
|
if (MainStarter::flCounter == 0)
|
|
|
|
{
|
|
|
|
stt->doEmitionRedFoundData("Empty IP list.");
|
|
|
|
globalScanFlag = false;
|
|
|
|
stt->doEmitionKillSttThread();
|
|
|
|
return;
|
|
|
|
};
|
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
struct in_addr tAddr;
|
2015-08-21 21:27:13 +00:00
|
|
|
|
|
|
|
switch (gShuffle) {
|
|
|
|
case true: {
|
|
|
|
int ipOffset = 6;
|
|
|
|
for (gflIndex = 0; gflIndex < MainStarter::flCounter; gflIndex += ipOffset)
|
|
|
|
{
|
2015-08-07 22:37:28 +00:00
|
|
|
int ipGap = MainStarter::flCounter - gflIndex;
|
|
|
|
if (ipGap < ipOffset)
|
|
|
|
{
|
|
|
|
ipOffset = ipGap;
|
|
|
|
};
|
|
|
|
|
2015-08-21 21:27:13 +00:00
|
|
|
std::vector<IPRangeHolder> ipRangeVec;
|
|
|
|
for (int j = gflIndex; j < gflIndex + ipOffset; ++j)
|
2015-08-07 22:37:28 +00:00
|
|
|
{
|
|
|
|
/*sprintf(metaRange, "%d.%d.%d.%d-%d.%d.%d.%d",
|
|
|
|
ipsstartfl[j][0], ipsstartfl[j][1], ipsstartfl[j][2], ipsstartfl[j][3],
|
|
|
|
ipsendfl[j][0], ipsendfl[j][1], ipsendfl[j][2], ipsendfl[j][3]);*/
|
|
|
|
ip1 = (ipsstartfl[j][0] * 16777216) +
|
|
|
|
(ipsstartfl[j][1] * 65536) +
|
|
|
|
(ipsstartfl[j][2] * 256) +
|
|
|
|
ipsstartfl[j][3];
|
|
|
|
ip2 = (ipsendfl[j][0] * 16777216) +
|
|
|
|
(ipsendfl[j][1] * 65536) +
|
|
|
|
(ipsendfl[j][2] * 256) +
|
|
|
|
ipsendfl[j][3];
|
|
|
|
|
2015-08-21 21:27:13 +00:00
|
|
|
IPRangeHolder holder;
|
|
|
|
holder.ip1 = ip1;
|
|
|
|
holder.ip2 = ip2;
|
|
|
|
ipRangeVec.push_back(holder);
|
2015-08-07 22:37:28 +00:00
|
|
|
}
|
2015-08-21 21:27:13 +00:00
|
|
|
IPRandomizer ipRandomizer(ipRangeVec, 20000);
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-21 21:27:13 +00:00
|
|
|
int ip = 0;
|
|
|
|
while ((ip = ipRandomizer.getNext()) != 0) {
|
2015-08-07 22:37:28 +00:00
|
|
|
while (cons >= gThreads && globalScanFlag) Sleep(500);
|
|
|
|
if (!globalScanFlag) goto haters_gonna_hate_IM;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
++indexIP;
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-21 21:27:13 +00:00
|
|
|
tAddr.s_addr = ntohl(ip);
|
|
|
|
strcpy(currentIP, inet_ntoa(tAddr));
|
2015-08-07 22:37:28 +00:00
|
|
|
verboseProgress(gTargets);
|
2015-04-14 11:58:33 +00:00
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
Threader::fireThread(currentIP, (void*(*)(void))_connect);
|
|
|
|
}
|
2015-08-21 21:27:13 +00:00
|
|
|
}
|
|
|
|
haters_gonna_hate_IM:;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case false: {
|
2016-01-31 20:09:42 +00:00
|
|
|
for (gflIndex = 0; gflIndex < MainStarter::flCounter; gflIndex++) {
|
|
|
|
if (!globalScanFlag) break;
|
|
|
|
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];
|
|
|
|
struct in_addr tAddr;
|
|
|
|
for (unsigned long i = ip1; i <= ip2; ++i) {
|
|
|
|
|
|
|
|
while (cons >= gThreads && globalScanFlag) Sleep(500);
|
|
|
|
if (!globalScanFlag) break;
|
2015-08-07 22:37:28 +00:00
|
|
|
|
2016-01-31 20:09:42 +00:00
|
|
|
++indexIP;
|
2015-08-07 22:37:28 +00:00
|
|
|
|
2016-01-31 20:09:42 +00:00
|
|
|
tAddr.s_addr = ntohl(i);
|
|
|
|
strcpy(currentIP, inet_ntoa(tAddr));
|
|
|
|
verboseProgress(gTargets);
|
|
|
|
Threader::fireThread(currentIP, (void*(*)(void))_connect);
|
|
|
|
}
|
|
|
|
}
|
2015-08-21 21:27:13 +00:00
|
|
|
break;
|
|
|
|
};
|
2015-04-14 11:58:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void MainStarter::runAuxiliaryThreads() {
|
|
|
|
|
|
|
|
FileUpdater::loadOnce();
|
|
|
|
if (!FileUpdater::running) {
|
|
|
|
std::thread lpThread(FileUpdater::updateLists);
|
|
|
|
lpThread.detach();
|
|
|
|
}
|
2015-12-11 23:13:28 +00:00
|
|
|
//if (!trackerRunning) {
|
|
|
|
// std::thread trackerThread(_tracker);
|
|
|
|
// trackerThread.detach();
|
|
|
|
//}
|
2015-04-14 11:58:33 +00:00
|
|
|
if (!ipPerSecTimer) {
|
|
|
|
std::thread timerThread(_IPPerSecTimer);
|
|
|
|
timerThread.detach();
|
|
|
|
}
|
|
|
|
if (!saverRunning) {
|
|
|
|
std::thread saverThread(&MainStarter::saver, this);
|
|
|
|
saverThread.detach();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-01 15:30:14 +00:00
|
|
|
void MainStarter::createResultFiles() {
|
2015-08-07 22:37:28 +00:00
|
|
|
char fileName[256] = { 0 };
|
2016-02-28 16:07:10 +00:00
|
|
|
sprintf(fileName, "./" DIR_NAME "%s_%s", Utils::getStartDate().c_str(), Utils::getCurrentTarget().c_str());
|
2015-04-23 05:23:02 +00:00
|
|
|
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
|
2015-08-07 22:37:28 +00:00
|
|
|
bool res = CreateDirectoryA(fileName, NULL);
|
|
|
|
if (!res) {
|
|
|
|
int err = GetLastError();
|
|
|
|
if (err != 183)
|
|
|
|
{
|
|
|
|
while (!res) {
|
|
|
|
stt->doEmitionRedFoundData("Failed to create \"" + QString::fromLocal8Bit(fileName) + "\" Err: " + QString::number(err));
|
|
|
|
res = CreateDirectoryA(fileName, NULL);
|
|
|
|
err = GetLastError();
|
|
|
|
Sleep(1000);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
stt->doEmitionYellowFoundData("Directory \"" + QString::fromLocal8Bit(fileName) + "\" already exists. Err: " + QString::number(err));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
stt->doEmitionGreenFoundData("Result directory \"" + QString::fromLocal8Bit(fileName) + "\" successfully created.");
|
|
|
|
}
|
2015-04-23 05:23:02 +00:00
|
|
|
#else
|
|
|
|
struct stat str = { 0 };
|
2015-08-07 22:37:28 +00:00
|
|
|
if (stat(fileName, &str) == -1) {
|
|
|
|
mkdir(fileName, 0700);
|
2015-04-23 05:23:02 +00:00
|
|
|
}
|
|
|
|
#endif
|
2015-05-01 15:30:14 +00:00
|
|
|
}
|
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
/* This array will store all of the mutexes available to OpenSSL. */
|
|
|
|
static MUTEX_TYPE *mutex_buf = NULL;
|
|
|
|
|
|
|
|
static void locking_function(int mode, int n, const char * file, int line)
|
|
|
|
{
|
|
|
|
if (mode & CRYPTO_LOCK)
|
|
|
|
MUTEX_LOCK(mutex_buf[n]);
|
|
|
|
else
|
|
|
|
MUTEX_UNLOCK(mutex_buf[n]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long id_function(void)
|
|
|
|
{
|
|
|
|
return ((unsigned long)THREAD_ID);
|
|
|
|
}
|
|
|
|
|
|
|
|
int thread_setup(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mutex_buf = (MUTEX_TYPE*)malloc(CRYPTO_num_locks() * sizeof(MUTEX_TYPE));
|
|
|
|
if (!mutex_buf)
|
|
|
|
return 0;
|
|
|
|
for (i = 0; i < CRYPTO_num_locks(); i++)
|
|
|
|
MUTEX_SETUP(mutex_buf[i]);
|
|
|
|
CRYPTO_set_id_callback(id_function);
|
|
|
|
CRYPTO_set_locking_callback(locking_function);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int thread_cleanup(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
if (!mutex_buf)
|
|
|
|
return 0;
|
|
|
|
CRYPTO_set_id_callback(NULL);
|
|
|
|
CRYPTO_set_locking_callback(NULL);
|
|
|
|
for (i = 0; i < CRYPTO_num_locks(); i++)
|
|
|
|
MUTEX_CLEANUP(mutex_buf[i]);
|
|
|
|
free(mutex_buf);
|
|
|
|
mutex_buf = NULL;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-05-01 15:30:14 +00:00
|
|
|
void MainStarter::start(const char* targets, const char* ports) {
|
2015-08-21 21:27:13 +00:00
|
|
|
std::srand(std::time(NULL));
|
|
|
|
|
2015-08-22 20:55:40 +00:00
|
|
|
MainStarter::flCounter = 0;
|
|
|
|
MainStarter::gflIndex = 0;
|
|
|
|
MainStarter::ipsstartfl = NULL;
|
|
|
|
MainStarter::ipsendfl = NULL;
|
2015-08-09 11:22:02 +00:00
|
|
|
HikVis::hikCounter = 0;
|
|
|
|
HikVis::rviCounter = 0;
|
2015-08-07 22:37:28 +00:00
|
|
|
saveBackup = true;
|
2015-05-01 15:30:14 +00:00
|
|
|
curl_global_init(CURL_GLOBAL_ALL);
|
|
|
|
|
2015-08-07 22:37:28 +00:00
|
|
|
thread_setup();
|
|
|
|
|
2016-02-28 16:07:10 +00:00
|
|
|
|
|
|
|
QString fileSuffix = QString(targets);
|
|
|
|
fileSuffix = fileSuffix.mid(fileSuffix.lastIndexOf("/") + 1);
|
|
|
|
Utils::setCurrentTarget(fileSuffix.toUtf8().constData());
|
2015-05-01 15:30:14 +00:00
|
|
|
createResultFiles();
|
2015-04-18 22:30:55 +00:00
|
|
|
|
|
|
|
if (loadTargets(targets) == -1 ||
|
|
|
|
loadPorts(ports, ',') == -1) {
|
|
|
|
stt->doEmitionKillSttThread();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-04-14 11:58:33 +00:00
|
|
|
globalScanFlag = true;
|
|
|
|
runAuxiliaryThreads();
|
|
|
|
|
|
|
|
if (gMode == 0) startIPScan();
|
|
|
|
else if (gMode == 1) startDNSScan();
|
|
|
|
else startImportScan();
|
|
|
|
|
|
|
|
stt->doEmitionYellowFoundData("Stopping threads...");
|
|
|
|
|
2015-04-18 22:30:55 +00:00
|
|
|
while (cons > 0 || jsonArr->size() > 0) Sleep(2000);
|
2015-08-22 20:55:40 +00:00
|
|
|
MainStarter::saveBK();
|
2015-08-21 21:53:31 +00:00
|
|
|
saveBackup = false;
|
2015-08-07 22:37:28 +00:00
|
|
|
|
|
|
|
thread_cleanup();
|
2015-04-14 11:58:33 +00:00
|
|
|
|
|
|
|
stt->doEmitionGreenFoundData("Done. Saved <u>" + QString::number(saved) +
|
|
|
|
"</u> of <u>" + QString::number(found) + "</u> nodes.");
|
|
|
|
stt->doEmitionKillSttThread();
|
2018-08-17 11:50:53 +00:00
|
|
|
}
|