dirp

#!/usr/bin/env node

const Promise = require("bluebird");
const Sugar = require("sugar");
const _progress = require('cli-progress');
const glob = require("glob");
const globals = require("./modules/globals");

Sugar.extend();
const modifyExtPaths = require('./modules/modifyExtPaths');
const lowercase = require('./modules/lowercase');
let globalResults = require('./modules/discoveries.js');
let globalBar;

const log = console.log;

let http_enum;
try {
  http_enum = require("./modules/http_enum");
} catch (err) {

}

var argv = require("yargs").argv,
  genCustomBackupFiles = require('./modules/customBackupFiles'),
  pathsToCheck = [],
  color = require("cli-color"),
  async = require("async"),
  fs = require("fs"),
  throttledQueue = require("throttled-queue"),
  Table = require('cli-table'),
  table = new Table(),
  totalChecks = 0,
  checkCounter = 0,
  rate = 75,
  lastPercent = 0,
  testResults = [];

(testString = ""),
  (debug = false),
  (jobs = 0),
  (jobsCount = 0),
  (test = false),
  (count = 0),
  (wordDir = require.resolve("cli-color"));

wordDir = wordDir.split("node_modules");
wordDir = wordDir[0];
var dictionaryFile = wordDir + "wordlists/default.txt";
if (argv.input || argv.wordlist || argv.w) {
  if (argv.input) {
    dictionaryFile = argv.input;
  }
  else if (argv.wordlist) {
    dictionaryFile = argv.wordlist;
  }
  else {
    dictionaryFile = argv.w;
  }
}

if (argv.rate) {
  rate = parseInt(argv.rate);
}

if (argv.t) {
  rate = parseInt(argv.t);
}

if (argv.delay){
  rate = 1
}


async function asyncForEach(array, callback) {
  for (let index = 0; index < array.length; index++) {
    await callback(array[index], index, array)
  }
}

async function prepPaths(payloadArray) {
  if (argv.help || argv.h || !argv.u) {
    console.log(color.green("\n--[Dirp Examples]--\n"));
    console.log("./dirp -u 'https://foo.bar/' --wordlist=/path/to/wordlist.txt (or /path/to/*.txt)");
    console.log("./dirp -u 'https://foo.bar/<INSERT>.jsp'");
    console.log(
      "./dirp -u 'https://foo.bar/' --cookie='sessionid=12345;foo=bar;'"
    );
    console.log("./dirp -u 'https://foo.bar/' --proxy='http://proxy.host:port'");
    //console.log("           '--rate 50 (max number of requests per second - default 250)");
    console.log("           -X or --method (use custom HTTP method)");
    console.log("           --lowercase (lowercase all paths)");
    console.log("           --ext .php (Replace any extensions in your wordlist(s) with a custom value)");
    console.log("           --compare Use response comparison to determine status");
    console.log("           --threshold [int] (Set threshold for comparison analysis, default 50)");
    console.log("           --debug (debug mode and show every request/response)");

    console.log();
    process.exit(1);
  } else if (argv.u) {

    if (argv.string) {
      testString = argv.string;
    }

    if (argv.debug) {
      debug = true;
    }


    let customBackups = genCustomBackupFiles(argv.u.split('/')[2]);

    payloadArray = payloadArray.reverse().concat(customBackups).reverse();

    if (argv.ext) {
      payloadArray = await modifyExtPaths(payloadArray, argv.ext);
    }

    if (argv.lowercase) {
      payloadArray = await lowercase(payloadArray);
    }


    totalChecks = payloadArray.length;

    const jobCount = payloadArray.length

    console.log(
      `\n[*] Preparing to run Dirp with ${dictionaryFile} (%s checks)\n`,
      payloadArray.length
    );


    return payloadArray

  }


}

async function dirpPath(checks, recurse, clibar) {
  let bar;
  if (typeof (recurse) != 'String') {
    bar = recurse;
    recurse = false;
  } else {
    bar = clibar;
  }

  if (!argv.debug) {
    bar.start(checks.length, 1);


    bar.update(0, {
      reqPath: '...',
      discoveries: '',
    });
  }


  return Promise.map(checks, function (pay) {
    if (recurse) {
      pay = `${recurse}/${pay}`;
    }

    return new Promise(function (resolve) {
      resolve(http_enum(argv.u, testString, debug, pay, bar))
    })

  }, { concurrency: rate })

}


function cleanResults(rawRes) {
  return rawRes.filter(function (el) {
    return el != null;
  });
}


(async function () {
  let data;
  let payloadArray = [];
  try {
    let fileGlob = glob.sync(dictionaryFile);
    for (i = 0; i < fileGlob.length; i++) {
      data = fs.readFileSync(fileGlob[i], "utf8");
      data.toString().split("\n")
      payloadArray = payloadArray.concat(data.toString().split("\n"));
    }
    payloadArray = payloadArray.unique();

  } catch (e) {
    console.log(e);
  }

  let e = await prepPaths(payloadArray);

  let bar = new _progress.Bar({
    format: '{bar} {percentage}% ' + '| {value}/{total} | Discovered: {discoveries} ',
    barCompleteChar: '\u2588',
    forceRedraw: true,
    clearOnComplete: true,
    barIncompleteChar: '\u2591',
    hideCursor: true
  });

  globalBar = bar;
  await globals.initialize();
  let results = await dirpPath(e, bar);
  var filtered = cleanResults(results);

  await asyncForEach(filtered, async (result) => {
    if (!result.path.includes('//') && result.path != '/' && result.path.length > 2) {
      pathsToCheck.push(result.path);
    }
  })

  if (argv.recurse || argv.r || argv.recursive) {
    await asyncForEach(pathsToCheck, async (num) => {

      let results = await dirpPath(e, num, bar);
      var filtered = cleanResults(results);
      for (i = 0; i < filtered.length; i++) {
        if (!filtered[i].path.includes('//') && filtered[i].path.length > 2) {
          pathsToCheck.push(filtered[i].path)
        }
      }

    })
  } else {
    if (!argv.debug) {
      bar.increment(-1, {
        reqPath: '...',
        discoveries: '',
      });
      bar.increment(1, {
        reqPath: '...',
        discoveries: globalResults.getDiscoveries().length.toString(),
      });
      bar.stop();
    }

  }

  process.on('exit', function () {

    handle();
  });



})()

function drawTable() {
  var resultsTable = new Table({
    head: ['Method', 'Url', 'Length', 'Status'],
    style: { compact: true, 'padding-left': 1 }
  });

  let finalDiscoveries = globalResults.getDiscoveries();

  for (i = 0; i < finalDiscoveries.length; i++) {
    let resStrSplit = finalDiscoveries[i].split(" ");

    resultsTable.push(
      [resStrSplit[0], resStrSplit[1], resStrSplit[2], resStrSplit[3]]
    );
  }

  console.log("");
  console.log(resultsTable.toString());
}
let hasPrintedResults = false;
async function handle(signal) {

  if (signal === "SIGINT") {
    globalBar.stop();
    //console.log(globalResults.getDiscoveries().join("\n"))
    hasPrintedResults = true;
  } else {
    if (!hasPrintedResults) {
      if (argv.table) {
        drawTable();
      }
      hasPrintedResults = true;
    }
  }

  process.exit(0);

}

process.on('SIGINT', handle);
process.on('SIGINT', handle);
process.on('SIGTERM', handle);