autoattack.js

import {fetchServers} from 'serverdata.js'
import {runTerminalCommand} from 'terminalcmd.js'
import {autoConnect} from 'autoconnect.js'

export function getAttackTargetCount(ns) {
  const serverResult = fetchServers(ns, "--attack", false);
  return serverResult.length;
}

export function isServerNuked(ns, hostNameTarget) {
  return ns.hasRootAccess(hostNameTarget) ? true : false;
}

export function isServerBackdoored(ns, targetHostname) {
  return ns.getServer(targetHostname).backdoorInstalled ? true : false;
}

export function isServerNukePossible(ns, hostNameTarget, portsOpened) {
  let serverRoot = ns.hasRootAccess(hostNameTarget);
  let serverNumPortsRequired = ns.getServerNumPortsRequired(hostNameTarget);
  return !serverRoot && portsOpened >= serverNumPortsRequired;
}

export function isServerBackdoorPossible(ns, targetHostname) {
  let hasRoot = ns.hasRootAccess(targetHostname);
  let isBackdoor = isServerBackdoored(ns, targetHostname);
  let playerHackLvl = ns.getHackingLevel();
  let serverRequiredHack = ns.getServerRequiredHackingLevel(targetHostname);
  return (hasRoot && !isBackdoor && playerHackLvl >= serverRequiredHack) ? true : false;
}

export function openPortsTarget(ns, hostNameTarget, verbose) {
  const portsRequired = ns.getServerNumPortsRequired(hostNameTarget);
  let portsOpened = 0;

  for(let exploitIdx = 0; exploitIdx < 5; exploitIdx++) {
    let isPortOpened = false;
 
    switch(exploitIdx) {
      case 0: {
        if(!ns.fileExists("SQLInject.exe")) {
          continue;
        }
        isPortOpened = ns.sqlinject(hostNameTarget) ? true : false;
      }
      case 1:{
        if(!ns.fileExists("HTTPWorm.exe")) {
          continue;
        }
        isPortOpened = ns.httpworm(hostNameTarget) ? true : false;
      }
      case 2:{
        if(!ns.fileExists("BruteSSH.exe")) {
          continue;
        }
        isPortOpened = ns.brutessh(hostNameTarget) ? true : false;
      }
      case 3:{
        if(!ns.fileExists("FTPCrack.exe")) {
          continue;
        }
        isPortOpened = ns.ftpcrack(hostNameTarget) ? true : false;
      }
      case 4:{
        if(!ns.fileExists("relaySMTP.exe")){
          continue;
        }
        isPortOpened = ns.relaysmtp(hostNameTarget) ? true : false;
      }
      default: {
        break; // out of range, break.
      }
    }

    if(isPortOpened) {
      portsOpened ++;
    }

    if(portsOpened >= portsRequired) {
      break; // no need to open any more ports
    }
  }

  if(verbose) {
    ns.tprintf("%s -> openPortsTarget(hostNameTarget=%s, verbose=%s) = %i/%i port(s) opened.", 
      ns.getScriptName(), hostNameTarget, verbose, portsOpened, portsRequired
    );
  }
  return portsOpened;
}

/**
1. auto-connects the path
2. runs backdoor on target server.
*/
export async function backdoorTarget(ns, targetHostname, skipCheck, verbose) {
  await autoConnect(ns, targetHostname, verbose);
  
  if(skipCheck || isServerBackdoorPossible(ns, targetHostname)) {
    // attempt backdoor

    await runTerminalCommand("backdoor");

    if(verbose) {
      ns.tprintf("%s -> backdoorTarget(targetHostname=%s, skipCheck=%s, verbose=%s) -> installing backdoor, please wait...", 
        ns.getScriptName(), targetHostname, skipCheck, verbose
      );
    }

    while( !isServerBackdoored(ns, targetHostname) ) {
      await ns.sleep(500);
    }

    if(verbose) {
      let backdoorSuccess = isServerBackdoored(ns, targetHostname) ? true : false;
      ns.tprintf("%s -> backdoorTarget(targetHostname=%s, skipCheck=%s, verbose=%s) -> backdoor install %s", 
        ns.getScriptName(), targetHostname, skipCheck, verbose, backdoorSuccess ? "successully." : "FAILED!"
      );
    }
  } else {
    // backdoor not possible or necessary.

    if(verbose) {
      ns.tprintf("%s -> backdoorTarget(targetHostname=%s, skipCheck=%s, verbose=%s) -> not possible / necessary.", 
        ns.getScriptName(), targetHostname, skipCheck, verbose
      );
    }
  }
}

export async function attackTarget(ns, hostNameTarget, verbose) {
  let portsOpened = 0;
  if( !isServerNuked(ns, hostNameTarget)) {
    portsOpened = openPortsTarget(ns, hostNameTarget, verbose);
  }

  if( isServerNukePossible(ns, hostNameTarget, portsOpened) ) {
    let nukeSuccess = ns.nuke(hostNameTarget);
    ns.tprintf("%s -> attackTarget(hostNameTarget=%s, verbose=%s) -> nuke %s", 
      ns.getScriptName(), hostNameTarget, verbose, nukeSuccess ? "successful." : "FAILED!"
    );
  }

  if( isServerBackdoorPossible(ns, hostNameTarget) ) {
    await backdoorTarget(ns, hostNameTarget, true, verbose);
  }
}

export async function autoAttack(ns, verbose) {
  const serverResult = fetchServers(ns, "--attack", verbose);
  const myScriptName = ns.getScriptName();

  if(verbose) {
    ns.tprintf("%s -> found %i attack target(s)...", myScriptName, serverResult.length);
  }

  for(let i = 0; i < serverResult.length; i++) {
    const targetHostName = serverResult[i];
    if(verbose) {
      ns.tprintf("%s -> autoAttack(verbose=%s) -> attacking target %i/%i", 
        myScriptName, verbose, i+1, serverResult.length);
    }
    await attackTarget(ns, targetHostName, verbose);
  }
}

/** @param {NS} ns */
export async function main(ns) {
  const verbose = true;
  await autoAttack(ns, verbose);
}