infect

//-----MEMORY SETTINGS-----//
//Place in script names to allocate RAM for them on this server.
let allocateFor = [ "covid.js", "scanForCCT.js"];
//Used to keep a certain amount of RAM free
let ramRequirements = 4;

//-----LOGGING SETTINGS-----//
//Logging - 1 = Critical/Application 2 = Extended 3 = All Logging
let doLog = true;
let logLevel = 1;

//-----FILTER SETTINGS-----//
/*You can prevent symptoms from running on computers by adding them to this list
It will look for servers that CONTAIN the values in the array unless usePreciseNaming
is true, in which it will only look for exact matches.
ex: ["MyServer-32768", "MyServer-1048576", "MyServer-1048576-0"] */
let usePreciseNaming = false;
let ignoreServers = ["MyServer-",];

//-----GUI SETTINGS-----//

let doGUI = true;
let showKarma = true;

//-----SINGULARITY SETTINGS -----//
//Enable this to enable singularity functionality
let haveSingularity = true;
//automate tor/program purchasing,
let torAutomate = true;
//automate backdoor installation
let doBackdoor = true;

//do not edit below this line unless you know what your doing.

let visited = ["home"];
let hackTarget;
let bestValue = ["home", 0];
let newBestValue = ["home", 0];
let firstRun = true;
let foundFiles = [];
let backdoored = [];

const doc = globalThis['document'];
const hook0 = doc.getElementById('overview-extra-hook-0');
const hook1 = doc.getElementById('overview-extra-hook-1');
//args - depth

/** @param {NS} ns */
export async function main(ns) {
    ns.exec("scanForCCT.js", "home");

    for (let s of allocateFor) {
        ramRequirements += ns.getScriptRam(s);
    }
    while (true) {

        const headers = [];
        const values = [];
        if (showKarma && doGUI){
            headers.push("Karma");
            values.push(ns.heart.break().toPrecision(5));
        }
        visited = ["home"];
        backdoored = [];
        //if (torAutomate)  await checkPlayer(ns);
        await updateTarget(ns);
        //await log(ns, visited.toString(), 1);
        if (bestValue[0] != newBestValue[0]) {
            log(ns, "Detected new best value as " + newBestValue[0] + " with a value of " + newBestValue[1], 1);
            bestValue = newBestValue;
        }
        if (firstRun) ns.tprint(visited.toString());
        firstRun = false;
        await ns.sleep(5000);

        hook0.innerText = headers.join(" \n");
        hook1.innerText = values.join(" \n");
    }
}

/** @param {NS} ns */
function ignored(s, ns) {
    if (usePreciseNaming == false) {
        for (let i of ignoreServers) {
            log(ns, "Comparing - " + s + "  to  " + i, 3);
            if (s.includes(i) || s == i) {
                log(ns, "In ignore list - " + s, 3);
                return true;
            }
        }
    } else {
        if (ignoreServers.includes(s)) {
            log(ns, "[PM] - In ignore list - " + s, 3);
            return true;
        }
    }
    log(ns, "Not in ignore list - " + s, 3);
    return false;
}
/** @param {NS} ns */
async function updateTarget(ns) {
    hackTarget = ns.read("target.txt");
    if (hackTarget != undefined && hackTarget != "") {
        if (!ns.hasRootAccess(hackTarget)) {
            await dropImmunity(ns, hackTarget);
        }
        if (ns.hasRootAccess(hackTarget)) {
            await contagious(ns, "home", ns.args[0]);
            if (ignored("home", ns) == false) await runSymptoms(ns, "home");
        } else { log(ns, "Cannot gain root access to - " + hackTarget, 1) }
    } else { log(ns, "Unable to read server name from target.txt", 1); }
}
/** @param {NS} ns */
async function log(ns, s, level) {
    if (doLog && level <= logLevel) ns.tprint(s);
}
/** @param {NS} ns */
async function dropImmunity(ns, server) {
    // If we have the BruteSSH.exe program, use it to open the SSH Port
    // on the target server
    let portLevel = 0;
    if (ns.fileExists("BruteSSH.exe", "home") && !ns.hasRootAccess(server) && ns.getServerNumPortsRequired(server) > portLevel) {
        log(ns, "Attempting BruteSSH on " + server, 2);
        ns.brutessh(server);
        portLevel++;
    }
    if (ns.fileExists("FTPCrack.exe", "home") && !ns.hasRootAccess(server) && ns.getServerNumPortsRequired(server) > portLevel) {
        log(ns, "Attempting FTPCrack on " + server, 2);
        ns.ftpcrack(server);
        portLevel++;
    }
    if (ns.fileExists("relaySMTP.exe", "home") && !ns.hasRootAccess(server) && ns.getServerNumPortsRequired(server) > portLevel) {
        log(ns, "Attempting relaySMTP on " + server, 2);
        ns.relaysmtp(server);
        portLevel++;
    }
    if (ns.fileExists("HTTPWorm.exe", "home") && !ns.hasRootAccess(server) && ns.getServerNumPortsRequired(server) > portLevel) {
        log(ns, "Attempting HTTPWorm on " + server, 2);
        ns.httpworm(server);
        portLevel++;
    }
    if (ns.fileExists("SQLInject.exe", "home") && !ns.hasRootAccess(server) && ns.getServerNumPortsRequired(server) > portLevel) {
        log(ns, "Attempting SQLInject on " + server, 2);
        ns.sqlinject(server);
        portLevel++;
    }


    // Get root access to target server
    if (!ns.hasRootAccess(server)) {
        if (ns.getServerNumPortsRequired(server) <= portLevel) {
            ns.nuke(server);
            if (ns.hasRootAccess(server)) {
                log(ns, "Gained root access to " + server, 1);
            }
        }
        else log(ns, "Not enough open ports for " + server + " to run NUKE.exe", 2);
    }
}

/** @param {NS} ns */
async function contagious(ns, root, depth) {
    log(ns, "Scanning " + root + " for nodes. Current Depth: " + depth, 3);
    let list = ns.scan(root);
    for (let server of list) {
        //termiate running scripts
        if (!visited.includes(server)) {
            //set we have visited it
            visited.push(server);
            if (depth > 0 || depth < 0) {
                //run contagious with that server as target
                await contagious(ns, server, depth - 1);
            }
            if (ignored(server, ns) == false) {
                await dropImmunity(ns, server);
                await runSymptoms(ns, server);
            }
            //if (doBackdoor) await backdoor(server, root, ns);
        }
    }
}
/** @param {NS} ns */
async function runSymptoms(ns, server) {
    if (ns.hasRootAccess(server)) {
        let d = ns.ps(server);
        let runningSymptoms = false;
        for (let process of d) {
            if (process.filename == "symptoms.js" && process.args[0] == hackTarget) {
                runningSymptoms = true;
                log(ns, "Symptoms already targeting proper target on " + server + " running on " + process.threads + " threads.", 3);
            }
        }
        if (!runningSymptoms) {
            ns.scriptKill("symptoms.js", server);
            //execute file transfers
            await ns.scp("symptoms.js", server);
            let threads;

            if (server == "home") {
                threads = Math.floor((ns.getServerMaxRam("home") - ramRequirements) / ns.getScriptRam("symptoms.js"));
                log(ns, "Home Threads: " + threads + "  RAM Available: " + (ns.getServerMaxRam(server) - ramRequirements) + "    RAM Needed: " + (ramRequirements), 1);
                //threads = 0;
            }
            else threads = Math.floor(ns.getServerMaxRam(server) / ns.getScriptRam("symptoms.js"));
            log(ns, "Executing symptoms on " + server + " with " + threads + " threads.", 3);
            if (threads > 0) ns.exec("symptoms.js", server, threads, hackTarget);
            else log(ns, "Not enough RAM on " + server + " to execute symptoms", 2);
        }

    } else log(ns, "No root access was obtained for " + server + " to run symptoms", 3);
}