big-mama-code

// select the server that will run the hack
/// TODO: should loop through all purchased servers
var attackHost = args[0];
var attackHostServer = getServer(attackHost);
var attackHostCores = attackHostServer.cpuCores;
var attackHostRam = getServerMaxRam(attackHost);

// what percent of the money on the server should be taken each hack
var pctTaken = .50;

// what factor does the post-hack money need to be multiplied by to reach max
var growthFactorReqd = 1 / (1 - pctTaken);

/// TODO: should be able to cycle through servers
var targetName = args[1];

// some functions require server object instead of label, so getting that out of the way
var targetServ = getServer(targetName);

// calculating all the server info in one place
var targetMaxMoney = getServerMaxMoney(targetName);
var targetMinSec = getServerMinSecurityLevel(targetName);
var targetGrowthRate = getServerGrowth(targetName);
var targetMoneyHacked = targetMaxMoney * pctTaken;

// check for root, get root if needed
if(!hasRootAccess(targetName)) {
	if(fileExists("BruteSSH.exe", "home")) {
		brutessh(targetName);
	}
	if(fileExists("FTPCrack.exe", "home")) {
		ftpcrack(targetName);
	}
	if(fileExists("relaySMTP.exe", "home")) {
		relaysmtp(targetName);
	}
	if(fileExists("HTTPWorm.exe", "home")) {
		httpworm(targetName);
	}
	if(fileExists("SQLInject.exe", "home")) {
		sqlinject(targetName);
	}
	nuke(targetName);
}

// if unable to get root, end script
if(!hasRootAccess(targetName) && (attackHost !== getHostname())) {
	tprint("Unable to get root access to " + targetName);
	tprint("Ending script without beginning hack");
	exit();
}


var bHack = "baby-hack.script";
var bGrow = "baby-grow.script";
var bWeakPostHack = "baby-weaken-post-hack.script";
var bWeakPostGrow = "baby-weaken-post-grow.script";

var jHack = "just-hack.script";
var jWeak = "just-weaken.script";
var jGrow = "just-grow.script";

// copy the baby scripts over to the attacker
if(attackHost !== "home") {
	scp(bHack, "home", attackHost);
	scp(bGrow, "home", attackHost);
	scp(bWeakPostHack, "home", attackHost);
	scp(bWeakPostGrow, "home", attackHost);
	scp(jHack, "home", attackHost);
	scp(jWeak, "home", attackHost);
	scp(jGrow, "home", attackHost);
}


// how much money does one hack thread take
var hackAmtPerThread = hackAnalyze(targetName) * targetMaxMoney;

// how many threads needed to take the desired %
var hackThreadsNeeded = targetMoneyHacked / hackAmtPerThread;
var hackSecurityImpact = hackAnalyzeSecurity(hackThreadsNeeded, attackHost);
var weakPostHackThreadsNeeded = 1 + hackSecurityImpact / 0.05;

var hackRunTime = getHackTime(targetName);
exec(jHack, attackHost, hackThreadsNeeded, targetName, 0);
tprint("Just hack running");
sleep(hackRunTime + 1000);
tprint("Just hack complete");
tprint("Server money at " + 100*getServerMoneyAvailable(targetName)/targetMaxMoney + "%");
tprint("Server security at " + getServerSecurityLevel(targetName));

var weakRunTimeTemp = getWeakenTime(targetName);
exec(jWeak, attackHost, weakPostHackThreadsNeeded, targetName, 0);
tprint("Just weak running");
sleep(weakRunTimeTemp + 1000);
tprint("Just weak complete");
tprint("Server money at " + 100*getServerMoneyAvailable(targetName)/targetMaxMoney + "%");
tprint("Server security at " + getServerSecurityLevel(targetName));


// how many threads are needed to grow the server money from post-hack level to maximum
var growThreadsNeeded = growthAnalyze(targetName, growthFactorReqd, attackHostCores);
var growSecurityImpact = growthAnalyzeSecurity(growThreadsNeeded, targetName, attackHostCores);
var weakPostGrowThreadsNeeded = 1 + growSecurityImpact / 0.05;


var growRunTime = getGrowTime(targetName);
tprint("Just grow running");
exec(jGrow, attackHost, growThreadsNeeded, targetName, 0);
sleep(growRunTime + 1000);
tprint("Just grow complete");
tprint("Server money at " + 100*getServerMoneyAvailable(targetName)/targetMaxMoney + "%");
tprint("Server security at " + getServerSecurityLevel(targetName));


weakRunTimeTemp = getWeakenTime(targetName);
tprint("Just weak running");
exec(jWeak, attackHost, weakPostGrowThreadsNeeded, targetName, 0);
sleep(weakRunTimeTemp + 1000);
tprint("Just weak complete");
tprint("Server money at " + 100*getServerMoneyAvailable(targetName)/targetMaxMoney + "%");
tprint("Server security at " + getServerSecurityLevel(targetName));


var weakRunTime = getWeakenTime(targetName);
// giving the cycle a 1/2-second buffer
var spacingBetweenEnds = 1000;
var cycleBufferTime = 1000;
var cycleDuration = weakRunTime + spacingBetweenEnds * 2 + cycleBufferTime;

// get the sleep args for the scripts
var hackSleepTime = cycleDuration - hackRunTime;
var growSleepTime = cycleDuration - growRunTime;

var hackFileRam = getScriptRam(bHack);
var growFileRam = getScriptRam(bGrow);
var weakFileRam = getScriptRam(bWeakPostHack);

var ramAvailable = attackHostRam - (hackFileRam * hackThreadsNeeded) - (growFileRam * growThreadsNeeded);
var weakSleepTime = cycleDuration - weakRunTime;

// the delays between calling scripts, such that they'll end in the proper sequence

var delay1 = spacingBetweenEnds * 2;
var delay2 = weakRunTime - growRunTime + spacingBetweenEnds - delay1;
var delay3 = weakRunTime - hackRunTime - spacingBetweenEnds - delay2;



tprint("Grow: " + growThreadsNeeded);
tprint("Weak: " + weakPostGrowThreadsNeeded);
if(weakPostGrowThreadsNeeded < 1) {
	weakPostGrowThreadsNeeded = 1;
	tprint("  Minimum 1 thread required");
}
tprint("Hack: " + hackThreadsNeeded);
tprint("Weak: " + weakPostHackThreadsNeeded);
if(weakPostHackThreadsNeeded < 1) {
	weakPostHackThreadsNeeded = 1;
	tprint("  Minimum 1 thread required");
}


// run the baby files
exec(bWeakPostHack, attackHost, weakPostHackThreadsNeeded, targetName, weakSleepTime);
sleep(delay1);

exec(bWeakPostGrow, attackHost, weakPostGrowThreadsNeeded, targetName, weakSleepTime);
sleep(delay2);

exec(bGrow, attackHost, growThreadsNeeded, targetName, growSleepTime);
sleep(delay3);

exec(bHack, attackHost, hackThreadsNeeded, targetName, hackSleepTime);