reconFTW is a tool designed to perform automated recon on a target domain by running the best set of tools to perform scanning and finding out vulnerabilities
Shell bug-bountybugbountybugbounty-tooldnshackingnucleiosintpenetration-testingpentestpentest-toolpentestingreconreconnaissancescannersecuritysecurity-toolssubdomainsubdomain-enumerationvulnerabilities
#!/usr/bin/env bats
setup() {
local project_root
project_root="$(cd "$(dirname "$BATS_TEST_FILENAME")/../.." && pwd)"
export SCRIPTPATH="$project_root"
export LOGFILE="/dev/null"
export bred='' bblue='' bgreen='' byellow='' yellow='' reset=''
export TEST_DIR="$BATS_TEST_TMPDIR/reconftw_new_tools"
mkdir -p "$TEST_DIR"
export dir="$TEST_DIR/target.example.com"
export called_fn_dir="$dir/.called_fn"
mkdir -p "$called_fn_dir" "$dir"
cd "$dir"
export MOCK_BIN="$TEST_DIR/mockbin"
mkdir -p "$MOCK_BIN"
export PATH="$MOCK_BIN:$PATH"
source "$project_root/reconftw.sh" --source-only
export domain="target.example.com"
export DIFF=false
export AXIOM=false
}
teardown() {
[[ -d "$TEST_DIR" ]] && rm -rf "$TEST_DIR"
}
@test "lfi generates one-parameter candidates and uses explicit budgets" {
mkdir -p gf .tmp vulns
printf '%s\n' 'https://target.example.com/download?file=1&q=test' > gf/lfi.txt
printf '%s\n' '/etc/passwd' > "$TEST_DIR/lfi_wordlist.txt"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
quiet=false
if [[ "${1:-}" == "-q" ]]; then
quiet=true
shift
fi
outfile="$1"
mkdir -p "$(dirname "$outfile")"
touch "$outfile"
while IFS= read -r line; do
[[ -z "$line" ]] && continue
if ! grep -Fxq -- "$line" "$outfile"; then
printf '%s\n' "$line" >> "$outfile"
if [[ "$quiet" != true ]]; then
printf '%s\n' "$line"
fi
fi
done
SH
chmod +x "$MOCK_BIN/anew"
cat > "$MOCK_BIN/interlace" <<'SH'
#!/usr/bin/env bash
raw_args="$*"
input=""
while [[ $# -gt 0 ]]; do
case "$1" in
-tL)
input="$2"
shift 2
;;
-c)
printf '%s\n' "$2" > "$TEST_DIR/lfi_ffuf_cmd.txt"
shift 2
;;
*)
shift
;;
esac
done
printf '%s\n' "$0 $raw_args" > "$TEST_DIR/lfi_interlace_args.txt"
if [[ -n "$input" ]]; then
head -n 1 "$input" | sed 's/^/| URL | /'
fi
SH
chmod +x "$MOCK_BIN/interlace"
export LFI=true
export DEEP=false
export DEEP_LIMIT=500
export lfi_wordlist="$TEST_DIR/lfi_wordlist.txt"
export HEADER="User-Agent: bats"
export LFI_INTERLACE_THREADS=3
export LFI_INTERLACE_TIMEOUT=44
export LFI_FFUF_THREADS=9
export LFI_FFUF_RATELIMIT=77
export LFI_FFUF_TIMEOUT=7
export LFI_FFUF_MAXTIME=33
export LFI_FOLLOW_REDIRECTS=false
export LFI_MAX_URLS=2
run lfi
[ "$status" -eq 0 ]
[ -s ".tmp/tmp_lfi.txt" ]
[ "$(wc -l < ".tmp/tmp_lfi.txt" | tr -d ' ')" -eq 2 ]
grep -qx 'https://target.example.com/download?file=FUZZ&q=test' ".tmp/tmp_lfi.txt"
grep -qx 'https://target.example.com/download?file=1&q=FUZZ' ".tmp/tmp_lfi.txt"
grep -q -- '-threads 3' "$TEST_DIR/lfi_interlace_args.txt"
grep -q -- '-timeout 44' "$TEST_DIR/lfi_interlace_args.txt"
grep -q -- '-noninteractive' "$TEST_DIR/lfi_ffuf_cmd.txt"
grep -q -- '-timeout 7' "$TEST_DIR/lfi_ffuf_cmd.txt"
grep -q -- '-maxtime 33' "$TEST_DIR/lfi_ffuf_cmd.txt"
grep -q -- '-rate 77' "$TEST_DIR/lfi_ffuf_cmd.txt"
! grep -q -- ' -r ' "$TEST_DIR/lfi_ffuf_cmd.txt"
[ -s "vulns/lfi.txt" ]
}
@test "ssti uses TInjA engine and writes compatible output" {
mkdir -p gf .tmp vulns
printf 'https://target.example.com/?q=test\n' > gf/ssti.txt
cat > "$MOCK_BIN/TInjA" <<'SH'
#!/usr/bin/env bash
report_dir=""
while [[ $# -gt 0 ]]; do
case "$1" in
--reportpath)
report_dir="$2"
shift 2
;;
*)
shift
;;
esac
done
mkdir -p "$report_dir"
printf '%s\n' '{"url":"https://target.example.com/?q=FUZZ","isWebpageVulnerable":true,"certainty":"high","parameters":[]}' > "${report_dir}/mock_Report.jsonl"
SH
chmod +x "$MOCK_BIN/TInjA"
export SSTI=true
export SSTI_ENGINE="TInjA"
export TInjA_RATELIMIT=0
export TInjA_TIMEOUT=15
export DEEP=false
export DEEP_LIMIT=500
run ssti
[ "$status" -eq 0 ]
[ -s "vulns/ssti.txt" ]
grep -q "target.example.com" "vulns/ssti.txt"
}
@test "brokenLinks supports second-order engine" {
mkdir -p webs .tmp vulns
printf 'https://target.example.com\n' > webs/webs_all.txt
printf '{"LogNon200Queries":{"script":"src"}}\n' > "$TEST_DIR/takeover.json"
cat > "$MOCK_BIN/second-order" <<'SH'
#!/usr/bin/env bash
out_dir=""
while [[ $# -gt 0 ]]; do
case "$1" in
-output)
out_dir="$2"
shift 2
;;
*)
shift
;;
esac
done
mkdir -p "$out_dir"
printf '%s\n' '{"https://target.example.com":{"script[src]":["https://cdn.dead.example.org/app.js"]}}' > "${out_dir}/non-200-url-attributes.json"
SH
chmod +x "$MOCK_BIN/second-order"
export BROKENLINKS=true
export BROKENLINKS_ENGINE="second-order"
export SECOND_ORDER_CONFIG="$TEST_DIR/takeover.json"
export SECOND_ORDER_DEPTH=1
export SECOND_ORDER_THREADS=4
export SECOND_ORDER_INSECURE=false
run brokenLinks
[ "$status" -eq 0 ]
[ -s "vulns/brokenLinks.txt" ]
grep -q "cdn.dead.example.org" "vulns/brokenLinks.txt"
}
@test "favirecon_tech stores normalized technology findings" {
mkdir -p webs .tmp
printf 'https://target.example.com\n' > webs/webs_all.txt
cat > "$MOCK_BIN/favirecon" <<'SH'
#!/usr/bin/env bash
outfile=""
while [[ $# -gt 0 ]]; do
case "$1" in
-o)
outfile="$2"
shift 2
;;
*)
shift
;;
esac
done
printf '%s\n' '{"URL":"https://target.example.com","Name":"GitLab","Hash":"12345"}' > "$outfile"
SH
chmod +x "$MOCK_BIN/favirecon"
export FAVIRECON=true
export FAVIRECON_CONCURRENCY=10
export FAVIRECON_TIMEOUT=10
export FAVIRECON_RATE_LIMIT=0
run favirecon_tech
[ "$status" -eq 0 ]
[ -s "webs/favirecon.txt" ]
grep -q "GitLab" "webs/favirecon.txt"
}
@test "apileaks merges scoped leak URLs into url_extract" {
mkdir -p osint
export tools="$TEST_DIR/tools"
mkdir -p "$tools/SwaggerSpy/venv/bin" "$tools/SwaggerSpy"
export outOfScope_file="$TEST_DIR/out_of_scope.txt"
printf '%s\n' 'swagger.target.example.com' > "$outOfScope_file"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
quiet=false
if [[ "${1:-}" == "-q" ]]; then
quiet=true
shift
fi
outfile="$1"
mkdir -p "$(dirname "$outfile")"
touch "$outfile"
while IFS= read -r line; do
[[ -z "$line" ]] && continue
if ! grep -Fxq -- "$line" "$outfile"; then
printf '%s\n' "$line" >> "$outfile"
if [[ "$quiet" != true ]]; then
printf '%s\n' "$line"
fi
fi
done
SH
chmod +x "$MOCK_BIN/anew"
cat > "$MOCK_BIN/urless" <<'SH'
#!/usr/bin/env bash
cat
SH
chmod +x "$MOCK_BIN/urless"
cat > "$MOCK_BIN/porch-pirate" <<'SH'
#!/usr/bin/env bash
printf '%s\n' 'https://api.target.example.com/v1/users?first=1'
SH
chmod +x "$MOCK_BIN/porch-pirate"
cat > "$tools/SwaggerSpy/venv/bin/python3" <<'SH'
#!/usr/bin/env bash
printf '%s\n' 'URL https://swagger.target.example.com/openapi.json'
SH
chmod +x "$tools/SwaggerSpy/venv/bin/python3"
printf '%s\n' 'print("mock")' > "$tools/SwaggerSpy/swaggerspy.py"
cat > "$MOCK_BIN/postleaksNg" <<'SH'
#!/usr/bin/env bash
out=""
while [[ $# -gt 0 ]]; do
case "$1" in
--output)
out="$2"
shift 2
;;
*)
shift
;;
esac
done
mkdir -p "$out"
printf '%s\n' '{"url":"https://postman.target.example.com/path?token=1"}' > "$out/postleaks.json"
printf '%s\n' '{"url":"https://outside.example.net/path?next=target.example.com"}' > "$out/postleaks-outside.json"
SH
chmod +x "$MOCK_BIN/postleaksNg"
cat > "$MOCK_BIN/trufflehog" <<'SH'
#!/usr/bin/env bash
printf '%s\n' '{"DetectorName":"mock"}'
SH
chmod +x "$MOCK_BIN/trufflehog"
export API_LEAKS=true
export OSINT=true
export API_LEAKS_POSTLEAKS=true
export POSTLEAKS_THREADS=2
run apileaks
[ "$status" -eq 0 ]
[ -s "osint/postman_leaks.txt" ]
grep -q "postman.target.example.com" "osint/postman_leaks.txt"
[ -s "webs/url_extract.txt" ]
grep -q '^https://api.target.example.com/v1/users?first=1$' "webs/url_extract.txt"
grep -q '^https://postman.target.example.com/path?token=1$' "webs/url_extract.txt"
! grep -q 'outside.example.net' "webs/url_extract.txt"
! grep -q 'swagger.target.example.com' "webs/url_extract.txt"
}
@test "jschecks merges only scoped JS-discovered URLs into url_extract" {
mkdir -p js webs .tmp subdomains
printf '%s\n' 'https://target.example.com/app.js' > .tmp/url_extract_js.txt
printf '%s\n' 'target.example.com' > subdomains/subdomains.txt
export outOfScope_file="$TEST_DIR/out_of_scope_js.txt"
printf '%s\n' 'graphql.target.example.com' > "$outOfScope_file"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
quiet=false
if [[ "${1:-}" == "-q" ]]; then
quiet=true
shift
fi
outfile="$1"
mkdir -p "$(dirname "$outfile")"
touch "$outfile"
while IFS= read -r line; do
[[ -z "$line" ]] && continue
if ! grep -Fxq -- "$line" "$outfile"; then
printf '%s\n' "$line" >> "$outfile"
if [[ "$quiet" != true ]]; then
printf '%s\n' "$line"
fi
fi
done
SH
chmod +x "$MOCK_BIN/anew"
cat > "$MOCK_BIN/urless" <<'SH'
#!/usr/bin/env bash
cat
SH
chmod +x "$MOCK_BIN/urless"
cat > "$MOCK_BIN/subjs" <<'SH'
#!/usr/bin/env bash
printf '%s\n' 'https://api.target.example.com/v1/users?id=1'
printf '%s\n' 'https://outside.example.net/relay?next=target.example.com'
printf '%s\n' 'https://target.example.com/logo.png'
printf '%s\n' 'https://target.example.com/app2.js'
SH
chmod +x "$MOCK_BIN/subjs"
cat > "$MOCK_BIN/httpx" <<'SH'
#!/usr/bin/env bash
while IFS= read -r url; do
[[ -z "$url" ]] && continue
printf '%s [200] [text/javascript]\n' "$url"
done
SH
chmod +x "$MOCK_BIN/httpx"
cat > "$MOCK_BIN/interlace" <<'SH'
#!/usr/bin/env bash
exit 0
SH
chmod +x "$MOCK_BIN/interlace"
cat > "$MOCK_BIN/xnLinkFinder" <<'SH'
#!/usr/bin/env bash
outfile=""
while [[ $# -gt 0 ]]; do
case "$1" in
-o)
outfile="$2"
shift 2
;;
*)
shift
;;
esac
done
printf '%s\n' 'https://graphql.target.example.com/query' > "$outfile"
printf '%s\n' 'https://evil.example.org/path?host=target.example.com' >> "$outfile"
SH
chmod +x "$MOCK_BIN/xnLinkFinder"
cat > "$MOCK_BIN/jsluice" <<'SH'
#!/usr/bin/env bash
exit 0
SH
chmod +x "$MOCK_BIN/jsluice"
cat > "$MOCK_BIN/mantra" <<'SH'
#!/usr/bin/env bash
exit 0
SH
chmod +x "$MOCK_BIN/mantra"
cat > "$MOCK_BIN/trufflehog" <<'SH'
#!/usr/bin/env bash
exit 0
SH
chmod +x "$MOCK_BIN/trufflehog"
export JSCHECKS=true
export AXIOM=false
export HTTPX_TIMEOUT=5
export HTTPX_THREADS=5
export HTTPX_RATELIMIT=0
export INTERLACE_THREADS=2
export XNLINKFINDER_DEPTH=1
run jschecks
[ "$status" -eq 0 ]
[ -s "webs/url_extract.txt" ]
grep -q '^https://api.target.example.com/v1/users?id=1$' "webs/url_extract.txt"
! grep -q 'outside.example.net' "webs/url_extract.txt"
! grep -q 'graphql.target.example.com' "webs/url_extract.txt"
}
@test "s3buckets uses cloud_enum and writes cloud_enum artifacts" {
mkdir -p subdomains .tmp
printf '%s\n' 'target.example.com' > subdomains/subdomains.txt
export S3BUCKETS=true
export CLOUD_ENUM_S3_PROFILE="optimized"
export CLOUD_ENUM_S3_THREADS=7
export ASSET_STORE=false
export AXIOM=false
export multi=""
export tools="$TEST_DIR/tools"
mkdir -p "$tools/cloud_enum/venv/bin" "$tools/cloud_enum/enum_tools"
printf '%s\n' 'corp' > "$tools/cloud_enum/enum_tools/fuzz.txt"
printf '%s\n' '1.1.1.1' > "$TEST_DIR/resolvers.txt"
export resolvers="$TEST_DIR/resolvers.txt"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
quiet=false
if [[ "${1:-}" == "-q" ]]; then
quiet=true
shift
fi
outfile="$1"
touch "$outfile"
while IFS= read -r line; do
[[ -z "$line" ]] && continue
if ! grep -Fxq -- "$line" "$outfile"; then
printf '%s\n' "$line" >> "$outfile"
if [[ "$quiet" != true ]]; then
printf '%s\n' "$line"
fi
fi
done
SH
chmod +x "$MOCK_BIN/anew"
cat > "$MOCK_BIN/unfurl" <<'SH'
#!/usr/bin/env bash
if [[ "${1:-}" == "format" ]] && [[ "${2:-}" == "%r" ]]; then
while IFS= read -r line; do
printf '%s\n' "${line%%.*}"
done
else
cat
fi
SH
chmod +x "$MOCK_BIN/unfurl"
cat > "$MOCK_BIN/s3scanner" <<'SH'
#!/usr/bin/env bash
printf '%s\n' 'scan-bucket'
SH
chmod +x "$MOCK_BIN/s3scanner"
cat > "$MOCK_BIN/trufflehog" <<'SH'
#!/usr/bin/env bash
printf '%s\n' "$*" >> "$TEST_DIR/trufflehog_calls.txt"
printf '%s\n' '{"DetectorName":"mock"}'
SH
chmod +x "$MOCK_BIN/trufflehog"
cat > "$tools/cloud_enum/cloud_enum.py" <<'PY'
print("mock")
PY
cat > "$tools/cloud_enum/venv/bin/python3" <<'SH'
#!/usr/bin/env bash
printf '%s\n' "$*" > "$TEST_DIR/cloud_enum_args.txt"
logfile=""
while [[ $# -gt 0 ]]; do
case "$1" in
-l)
logfile="$2"
shift 2
;;
*)
shift
;;
esac
done
mkdir -p "$(dirname "$logfile")"
cat > "$logfile" <<'JSON'
#### CLOUD_ENUM TEST ####
{"platform":"aws","msg":"OPEN S3 BUCKET","target":"http://demo.s3.amazonaws.com","access":"public"}
{"platform":"gcp","msg":"OPEN GOOGLE BUCKET","target":"http://storage.googleapis.com/public-gcp","access":"public"}
{"platform":"gcp","msg":"Protected Google Bucket","target":"http://storage.googleapis.com/protected-gcp","access":"protected"}
JSON
exit 0
SH
chmod +x "$tools/cloud_enum/venv/bin/python3"
run s3buckets
[ "$status" -eq 0 ]
[ -s "subdomains/.cloud_enum_s3.jsonl" ]
grep -q 'demo.s3.amazonaws.com' "subdomains/.cloud_enum_s3.jsonl"
grep -q 'storage.googleapis.com/public-gcp' "subdomains/.cloud_enum_s3.jsonl"
[ -s "subdomains/cloud_assets.txt" ]
grep -q '^http://demo.s3.amazonaws.com$' "subdomains/cloud_assets.txt"
[ -s "subdomains/cloud_enum_buckets_trufflehog.txt" ]
grep -q -- '--bucket=demo' "$TEST_DIR/trufflehog_calls.txt"
grep -q -- '--project-id=public-gcp' "$TEST_DIR/trufflehog_calls.txt"
grep -Eq -- '(^| )-qs( |$)' "$TEST_DIR/cloud_enum_args.txt"
grep -Eq -- "(^| )-m $tools/cloud_enum/enum_tools/fuzz.txt( |$)" "$TEST_DIR/cloud_enum_args.txt"
grep -Eq -- "(^| )-b $tools/cloud_enum/enum_tools/fuzz.txt( |$)" "$TEST_DIR/cloud_enum_args.txt"
}
@test "s3buckets falls back to uv run when local venv is missing" {
mkdir -p subdomains .tmp
printf '%s\n' 'target.example.com' > subdomains/subdomains.txt
export S3BUCKETS=true
export CLOUD_ENUM_S3_PROFILE="optimized"
export CLOUD_ENUM_S3_THREADS=7
export ASSET_STORE=false
export AXIOM=false
export multi=""
export tools="$TEST_DIR/tools"
mkdir -p "$tools/cloud_enum"
printf '%s\n' 'print("mock")' > "$tools/cloud_enum/cloud_enum.py"
printf '%s\n' 'dnspython' > "$tools/cloud_enum/requirements.txt"
printf '%s\n' '1.1.1.1' > "$TEST_DIR/resolvers.txt"
export resolvers="$TEST_DIR/resolvers.txt"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
quiet=false
if [[ "${1:-}" == "-q" ]]; then
quiet=true
shift
fi
outfile="$1"
touch "$outfile"
while IFS= read -r line; do
[[ -z "$line" ]] && continue
if ! grep -Fxq -- "$line" "$outfile"; then
printf '%s\n' "$line" >> "$outfile"
if [[ "$quiet" != true ]]; then
printf '%s\n' "$line"
fi
fi
done
SH
chmod +x "$MOCK_BIN/anew"
cat > "$MOCK_BIN/unfurl" <<'SH'
#!/usr/bin/env bash
if [[ "${1:-}" == "format" ]] && [[ "${2:-}" == "%r" ]]; then
while IFS= read -r line; do
printf '%s\n' "${line%%.*}"
done
else
cat
fi
SH
chmod +x "$MOCK_BIN/unfurl"
cat > "$MOCK_BIN/s3scanner" <<'SH'
#!/usr/bin/env bash
printf '%s\n' 'scan-bucket'
SH
chmod +x "$MOCK_BIN/s3scanner"
cat > "$MOCK_BIN/trufflehog" <<'SH'
#!/usr/bin/env bash
printf '%s\n' '{"DetectorName":"mock"}'
SH
chmod +x "$MOCK_BIN/trufflehog"
cat > "$MOCK_BIN/uv" <<'SH'
#!/usr/bin/env bash
printf '%s\n' "$*" > "$TEST_DIR/cloud_enum_uv_args.txt"
logfile=""
while [[ $# -gt 0 ]]; do
case "$1" in
-l)
logfile="$2"
shift 2
;;
*)
shift
;;
esac
done
mkdir -p "$(dirname "$logfile")"
cat > "$logfile" <<'JSON'
{"platform":"aws","msg":"OPEN S3 BUCKET","target":"http://demo.s3.amazonaws.com","access":"public"}
JSON
exit 0
SH
chmod +x "$MOCK_BIN/uv"
run s3buckets
[ "$status" -eq 0 ]
[[ "$output" != *"runtime missing"* ]]
[ -s "$TEST_DIR/cloud_enum_uv_args.txt" ]
grep -Eq -- '(^| )run( |$)' "$TEST_DIR/cloud_enum_uv_args.txt"
grep -Fq -- "--directory $tools/cloud_enum" "$TEST_DIR/cloud_enum_uv_args.txt"
grep -Eq -- '(^| )-f json( |$)' "$TEST_DIR/cloud_enum_uv_args.txt"
grep -Eq -- "(^| )-m $tools/cloud_enum/cloud_enum.py( |$)" "$TEST_DIR/cloud_enum_uv_args.txt"
grep -Eq -- "(^| )-b $tools/cloud_enum/cloud_enum.py( |$)" "$TEST_DIR/cloud_enum_uv_args.txt"
[ -s "subdomains/.cloud_enum_s3.jsonl" ]
grep -q 'demo.s3.amazonaws.com' "subdomains/.cloud_enum_s3.jsonl"
}
@test "s3buckets exhaustive profile uses cloud_enum fuzz.txt mutations" {
mkdir -p subdomains .tmp
printf '%s\n' 'target.example.com' > subdomains/subdomains.txt
export S3BUCKETS=true
export CLOUD_ENUM_S3_PROFILE="exhaustive"
export CLOUD_ENUM_S3_THREADS=7
export ASSET_STORE=false
export AXIOM=false
export multi=""
export tools="$TEST_DIR/tools"
mkdir -p "$tools/cloud_enum/venv/bin" "$tools/cloud_enum/enum_tools"
printf '%s\n' 'corp' > "$tools/cloud_enum/enum_tools/fuzz.txt"
printf '%s\n' '1.1.1.1' > "$TEST_DIR/resolvers.txt"
export resolvers="$TEST_DIR/resolvers.txt"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
quiet=false
if [[ "${1:-}" == "-q" ]]; then
quiet=true
shift
fi
outfile="$1"
touch "$outfile"
while IFS= read -r line; do
[[ -z "$line" ]] && continue
if ! grep -Fxq -- "$line" "$outfile"; then
printf '%s\n' "$line" >> "$outfile"
if [[ "$quiet" != true ]]; then
printf '%s\n' "$line"
fi
fi
done
SH
chmod +x "$MOCK_BIN/anew"
cat > "$MOCK_BIN/unfurl" <<'SH'
#!/usr/bin/env bash
if [[ "${1:-}" == "format" ]] && [[ "${2:-}" == "%r" ]]; then
while IFS= read -r line; do
printf '%s\n' "${line%%.*}"
done
else
cat
fi
SH
chmod +x "$MOCK_BIN/unfurl"
cat > "$MOCK_BIN/s3scanner" <<'SH'
#!/usr/bin/env bash
printf '%s\n' 'scan-bucket'
SH
chmod +x "$MOCK_BIN/s3scanner"
cat > "$MOCK_BIN/trufflehog" <<'SH'
#!/usr/bin/env bash
printf '%s\n' '{"DetectorName":"mock"}'
SH
chmod +x "$MOCK_BIN/trufflehog"
cat > "$tools/cloud_enum/cloud_enum.py" <<'PY'
print("mock")
PY
cat > "$tools/cloud_enum/venv/bin/python3" <<'SH'
#!/usr/bin/env bash
printf '%s\n' "$*" > "$TEST_DIR/cloud_enum_args_exhaustive.txt"
logfile=""
while [[ $# -gt 0 ]]; do
case "$1" in
-l)
logfile="$2"
shift 2
;;
*)
shift
;;
esac
done
mkdir -p "$(dirname "$logfile")"
cat > "$logfile" <<'JSON'
{"platform":"aws","msg":"OPEN S3 BUCKET","target":"http://demo.s3.amazonaws.com","access":"public"}
JSON
exit 0
SH
chmod +x "$tools/cloud_enum/venv/bin/python3"
run s3buckets
[ "$status" -eq 0 ]
grep -Fq -- "-m $tools/cloud_enum/enum_tools/fuzz.txt" "$TEST_DIR/cloud_enum_args_exhaustive.txt"
grep -Fq -- "-b $tools/cloud_enum/enum_tools/fuzz.txt" "$TEST_DIR/cloud_enum_args_exhaustive.txt"
! grep -Eq -- '(^| )-qs( |$)' "$TEST_DIR/cloud_enum_args_exhaustive.txt"
}
@test "s3buckets continues with s3scanner when cloud_enum fails" {
mkdir -p subdomains .tmp
printf '%s\n' 'target.example.com' > subdomains/subdomains.txt
export S3BUCKETS=true
export CLOUD_ENUM_S3_PROFILE="optimized"
export CLOUD_ENUM_S3_THREADS=7
export ASSET_STORE=false
export AXIOM=false
export tools="$TEST_DIR/tools"
mkdir -p "$tools/cloud_enum/venv/bin" "$tools/cloud_enum"
printf '%s\n' '1.1.1.1' > "$TEST_DIR/resolvers.txt"
export resolvers="$TEST_DIR/resolvers.txt"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
quiet=false
if [[ "${1:-}" == "-q" ]]; then
quiet=true
shift
fi
outfile="$1"
touch "$outfile"
while IFS= read -r line; do
[[ -z "$line" ]] && continue
if ! grep -Fxq -- "$line" "$outfile"; then
printf '%s\n' "$line" >> "$outfile"
if [[ "$quiet" != true ]]; then
printf '%s\n' "$line"
fi
fi
done
SH
chmod +x "$MOCK_BIN/anew"
cat > "$MOCK_BIN/unfurl" <<'SH'
#!/usr/bin/env bash
if [[ "${1:-}" == "format" ]] && [[ "${2:-}" == "%r" ]]; then
while IFS= read -r line; do
printf '%s\n' "${line%%.*}"
done
else
cat
fi
SH
chmod +x "$MOCK_BIN/unfurl"
cat > "$MOCK_BIN/s3scanner" <<'SH'
#!/usr/bin/env bash
printf '%s\n' 'scan-bucket-fallback'
SH
chmod +x "$MOCK_BIN/s3scanner"
cat > "$MOCK_BIN/trufflehog" <<'SH'
#!/usr/bin/env bash
printf '%s\n' '{"DetectorName":"mock"}'
SH
chmod +x "$MOCK_BIN/trufflehog"
cat > "$tools/cloud_enum/cloud_enum.py" <<'PY'
print("mock")
PY
cat > "$tools/cloud_enum/venv/bin/python3" <<'SH'
#!/usr/bin/env bash
exit 1
SH
chmod +x "$tools/cloud_enum/venv/bin/python3"
run s3buckets
[ "$status" -eq 0 ]
[ -f "subdomains/.cloud_enum_s3.jsonl" ]
[ ! -s "subdomains/.cloud_enum_s3.jsonl" ]
[ -s "subdomains/s3buckets.txt" ]
grep -q '^scan-bucket-fallback$' "subdomains/s3buckets.txt"
}
@test "cloud_enum_scan uses local cloud_enum runtime with optimized quickscan flags" {
mkdir -p osint
export OSINT=true
export CLOUD_ENUM=true
export ASSET_STORE=false
export tools="$TEST_DIR/tools"
mkdir -p "$tools/cloud_enum/venv/bin" "$tools/cloud_enum"
printf '%s\n' '1.1.1.1' > "$TEST_DIR/resolvers.txt"
export resolvers="$TEST_DIR/resolvers.txt"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
quiet=false
if [[ "${1:-}" == "-q" ]]; then
quiet=true
shift
fi
outfile="$1"
touch "$outfile"
while IFS= read -r line; do
[[ -z "$line" ]] && continue
if ! grep -Fxq -- "$line" "$outfile"; then
printf '%s\n' "$line" >> "$outfile"
if [[ "$quiet" != true ]]; then
printf '%s\n' "$line"
fi
fi
done
SH
chmod +x "$MOCK_BIN/anew"
cat > "$MOCK_BIN/unfurl" <<'SH'
#!/usr/bin/env bash
if [[ "${1:-}" == "format" ]] && [[ "${2:-}" == "%r" ]]; then
while IFS= read -r line; do
printf '%s\n' "${line%%.*}"
done
else
cat
fi
SH
chmod +x "$MOCK_BIN/unfurl"
cat > "$tools/cloud_enum/cloud_enum.py" <<'PY'
print("mock")
PY
cat > "$tools/cloud_enum/venv/bin/python3" <<'SH'
#!/usr/bin/env bash
printf '%s\n' "$*" > "$TEST_DIR/cloud_enum_scan_args.txt"
printf '%s\n' 'OPEN S3 BUCKET: http://demo.s3.amazonaws.com'
exit 0
SH
chmod +x "$tools/cloud_enum/venv/bin/python3"
run cloud_enum_scan
[ "$status" -eq 0 ]
[ -s "osint/cloud_enum.txt" ]
grep -q 'OPEN S3 BUCKET' "osint/cloud_enum.txt"
grep -q -- 'cloud_enum.py' "$TEST_DIR/cloud_enum_scan_args.txt"
grep -Eq -- '(^| )-qs( |$)' "$TEST_DIR/cloud_enum_scan_args.txt"
grep -Eq -- "(^| )-m $tools/cloud_enum/cloud_enum.py( |$)" "$TEST_DIR/cloud_enum_scan_args.txt"
grep -Eq -- "(^| )-b $tools/cloud_enum/cloud_enum.py( |$)" "$TEST_DIR/cloud_enum_scan_args.txt"
}
@test "cloud_enum_scan falls back to uv run when local venv is missing" {
mkdir -p osint
export OSINT=true
export CLOUD_ENUM=true
export ASSET_STORE=false
export tools="$TEST_DIR/tools"
mkdir -p "$tools/cloud_enum"
printf '%s\n' 'print("mock")' > "$tools/cloud_enum/cloud_enum.py"
printf '%s\n' 'dnspython' > "$tools/cloud_enum/requirements.txt"
printf '%s\n' '1.1.1.1' > "$TEST_DIR/resolvers.txt"
export resolvers="$TEST_DIR/resolvers.txt"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
quiet=false
if [[ "${1:-}" == "-q" ]]; then
quiet=true
shift
fi
outfile="$1"
touch "$outfile"
while IFS= read -r line; do
[[ -z "$line" ]] && continue
if ! grep -Fxq -- "$line" "$outfile"; then
printf '%s\n' "$line" >> "$outfile"
if [[ "$quiet" != true ]]; then
printf '%s\n' "$line"
fi
fi
done
SH
chmod +x "$MOCK_BIN/anew"
cat > "$MOCK_BIN/unfurl" <<'SH'
#!/usr/bin/env bash
if [[ "${1:-}" == "format" ]] && [[ "${2:-}" == "%r" ]]; then
while IFS= read -r line; do
printf '%s\n' "${line%%.*}"
done
else
cat
fi
SH
chmod +x "$MOCK_BIN/unfurl"
cat > "$MOCK_BIN/uv" <<'SH'
#!/usr/bin/env bash
printf '%s\n' "$*" > "$TEST_DIR/cloud_enum_scan_uv_args.txt"
printf '%s\n' 'OPEN S3 BUCKET: http://demo.s3.amazonaws.com'
exit 0
SH
chmod +x "$MOCK_BIN/uv"
run cloud_enum_scan
[ "$status" -eq 0 ]
[[ "$output" != *"runtime not found"* ]]
[ -s "osint/cloud_enum.txt" ]
grep -q 'OPEN S3 BUCKET' "osint/cloud_enum.txt"
[ -s "$TEST_DIR/cloud_enum_scan_uv_args.txt" ]
grep -Eq -- '(^| )run( |$)' "$TEST_DIR/cloud_enum_scan_uv_args.txt"
grep -Fq -- "--directory $tools/cloud_enum" "$TEST_DIR/cloud_enum_scan_uv_args.txt"
grep -Eq -- '(^| )-qs( |$)' "$TEST_DIR/cloud_enum_scan_uv_args.txt"
grep -Eq -- "(^| )-m $tools/cloud_enum/cloud_enum.py( |$)" "$TEST_DIR/cloud_enum_scan_uv_args.txt"
grep -Eq -- "(^| )-b $tools/cloud_enum/cloud_enum.py( |$)" "$TEST_DIR/cloud_enum_scan_uv_args.txt"
}
@test "cloud_enum_scan exhaustive profile uses local fuzz mutations file" {
mkdir -p osint
export OSINT=true
export CLOUD_ENUM=true
export ASSET_STORE=false
export CLOUD_ENUM_S3_PROFILE="exhaustive"
export tools="$TEST_DIR/tools"
mkdir -p "$tools/cloud_enum/venv/bin" "$tools/cloud_enum/enum_tools"
printf '%s\n' 'corp' > "$tools/cloud_enum/enum_tools/fuzz.txt"
printf '%s\n' '1.1.1.1' > "$TEST_DIR/resolvers.txt"
export resolvers="$TEST_DIR/resolvers.txt"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
quiet=false
if [[ "${1:-}" == "-q" ]]; then
quiet=true
shift
fi
outfile="$1"
touch "$outfile"
while IFS= read -r line; do
[[ -z "$line" ]] && continue
if ! grep -Fxq -- "$line" "$outfile"; then
printf '%s\n' "$line" >> "$outfile"
if [[ "$quiet" != true ]]; then
printf '%s\n' "$line"
fi
fi
done
SH
chmod +x "$MOCK_BIN/anew"
cat > "$MOCK_BIN/unfurl" <<'SH'
#!/usr/bin/env bash
if [[ "${1:-}" == "format" ]] && [[ "${2:-}" == "%r" ]]; then
while IFS= read -r line; do
printf '%s\n' "${line%%.*}"
done
else
cat
fi
SH
chmod +x "$MOCK_BIN/unfurl"
cat > "$tools/cloud_enum/cloud_enum.py" <<'PY'
print("mock")
PY
cat > "$tools/cloud_enum/venv/bin/python3" <<'SH'
#!/usr/bin/env bash
printf '%s\n' "$*" > "$TEST_DIR/cloud_enum_scan_exhaustive_args.txt"
printf '%s\n' 'OPEN S3 BUCKET: http://demo.s3.amazonaws.com'
exit 0
SH
chmod +x "$tools/cloud_enum/venv/bin/python3"
run cloud_enum_scan
[ "$status" -eq 0 ]
[ -s "osint/cloud_enum.txt" ]
grep -q 'OPEN S3 BUCKET' "osint/cloud_enum.txt"
grep -Fq -- "-m $tools/cloud_enum/enum_tools/fuzz.txt" "$TEST_DIR/cloud_enum_scan_exhaustive_args.txt"
grep -Fq -- "-b $tools/cloud_enum/enum_tools/fuzz.txt" "$TEST_DIR/cloud_enum_scan_exhaustive_args.txt"
! grep -Eq -- '(^| )-qs( |$)' "$TEST_DIR/cloud_enum_scan_exhaustive_args.txt"
}
@test "cloud_enum_scan exhaustive downgrades to optimized when fuzz file is missing" {
mkdir -p osint
export OSINT=true
export CLOUD_ENUM=true
export ASSET_STORE=false
export CLOUD_ENUM_S3_PROFILE="exhaustive"
export tools="$TEST_DIR/tools"
mkdir -p "$tools/cloud_enum/venv/bin" "$tools/cloud_enum"
printf '%s\n' '1.1.1.1' > "$TEST_DIR/resolvers.txt"
export resolvers="$TEST_DIR/resolvers.txt"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
quiet=false
if [[ "${1:-}" == "-q" ]]; then
quiet=true
shift
fi
outfile="$1"
touch "$outfile"
while IFS= read -r line; do
[[ -z "$line" ]] && continue
if ! grep -Fxq -- "$line" "$outfile"; then
printf '%s\n' "$line" >> "$outfile"
if [[ "$quiet" != true ]]; then
printf '%s\n' "$line"
fi
fi
done
SH
chmod +x "$MOCK_BIN/anew"
cat > "$MOCK_BIN/unfurl" <<'SH'
#!/usr/bin/env bash
if [[ "${1:-}" == "format" ]] && [[ "${2:-}" == "%r" ]]; then
while IFS= read -r line; do
printf '%s\n' "${line%%.*}"
done
else
cat
fi
SH
chmod +x "$MOCK_BIN/unfurl"
cat > "$tools/cloud_enum/cloud_enum.py" <<'PY'
print("mock")
PY
cat > "$tools/cloud_enum/venv/bin/python3" <<'SH'
#!/usr/bin/env bash
printf '%s\n' "$*" > "$TEST_DIR/cloud_enum_scan_missing_fuzz_args.txt"
exit 0
SH
chmod +x "$tools/cloud_enum/venv/bin/python3"
run cloud_enum_scan
[ "$status" -eq 0 ]
grep -q "using optimized" <<<"$output"
[ -s "$TEST_DIR/cloud_enum_scan_missing_fuzz_args.txt" ]
grep -Eq -- '(^| )-qs( |$)' "$TEST_DIR/cloud_enum_scan_missing_fuzz_args.txt"
grep -Eq -- "(^| )-m $tools/cloud_enum/cloud_enum.py( |$)" "$TEST_DIR/cloud_enum_scan_missing_fuzz_args.txt"
grep -Eq -- "(^| )-b $tools/cloud_enum/cloud_enum.py( |$)" "$TEST_DIR/cloud_enum_scan_missing_fuzz_args.txt"
}
@test "multi_osint executes cloud_enum_scan for each target" {
export multi="multi-osint-test"
export list="$TEST_DIR/targets.txt"
printf '%s\n' 'one.example.com' 'two.example.com' > "$list"
export SCRIPTPATH="$TEST_DIR"
domain_info() { :; }
ip_info() { :; }
emails() { :; }
google_dorks() { :; }
github_repos() { :; }
github_leaks() { :; }
metadata() { :; }
apileaks() { :; }
third_party_misconfigs() { :; }
zonetransfer() { :; }
cloud_enum_scan() { printf '%s\n' "$domain" >> "$TEST_DIR/cloud_enum_scan_calls.txt"; }
init_dns_resolver() { :; }
enable_command_trace() { :; }
end() { :; }
run multi_osint
[ "$status" -eq 0 ]
[ -s "$TEST_DIR/cloud_enum_scan_calls.txt" ]
[ "$(wc -l < "$TEST_DIR/cloud_enum_scan_calls.txt")" -eq 2 ]
grep -q '^one.example.com$' "$TEST_DIR/cloud_enum_scan_calls.txt"
grep -q '^two.example.com$' "$TEST_DIR/cloud_enum_scan_calls.txt"
}
@test "nuclei_dast is forced on when VULNS_GENERAL=true" {
mkdir -p webs .tmp gf vulns nuclei_output
printf 'https://target.example.com\n' > webs/webs_all.txt
# Mock nuclei: write one JSON line when -o <file> is used; no-op for update calls.
cat > "$MOCK_BIN/nuclei" <<'SH'
#!/usr/bin/env bash
outfile=""
while [[ $# -gt 0 ]]; do
case "$1" in
-o)
outfile="$2"
shift 2
;;
*)
shift
;;
esac
done
if [[ -n "$outfile" ]]; then
mkdir -p "$(dirname "$outfile")"
printf '%s\n' '{"template-id":"mock-dast","type":"http","info":{"severity":"high"},"host":"https://target.example.com","matched-at":"https://target.example.com/"}' > "$outfile"
fi
exit 0
SH
chmod +x "$MOCK_BIN/nuclei"
export VULNS_GENERAL=true
export NUCLEI_DAST=false
export NUCLEI_RATELIMIT=10
export DEEP=false
export DEEP_LIMIT2=1500
export NUCLEI_TEMPLATES_PATH="$TEST_DIR/nuclei-templates"
mkdir -p "$NUCLEI_TEMPLATES_PATH/dast"
run nuclei_dast
[ "$status" -eq 0 ]
[ -s "nuclei_output/dast_json.txt" ]
[ -s "vulns/nuclei_dast.txt" ]
grep -q "mock-dast" "vulns/nuclei_dast.txt"
}
@test "github_leaks searches GitHub-wide secrets with ghleaks" {
mkdir -p osint
export tools="$TEST_DIR/tools"
mkdir -p "$tools/ghleaks"
# Create mock ghleaks binary
cat > "$tools/ghleaks/ghleaks" <<'SH'
#!/usr/bin/env bash
report=""
while [[ $# -gt 0 ]]; do
case "$1" in
--report)
report="$2"
shift 2
;;
*)
shift
;;
esac
done
if [[ -n "$report" ]]; then
printf '%s\n' '{"RuleID":"generic-api-key","Match":"AKIA1234567890ABCDEF","File":"config.yml","URL":"https://github.com/example/repo/blob/main/config.yml"}' > "$report"
fi
SH
chmod +x "$tools/ghleaks/ghleaks"
# Create GitHub tokens file
printf '%s\n' 'ghp_mock_token_12345' > "$TEST_DIR/.github_tokens"
export GITHUB_TOKENS="$TEST_DIR/.github_tokens"
export GITHUB_LEAKS=true
export OSINT=true
export DEEP=false
export GHLEAKS_THREADS=2
run github_leaks
[ "$status" -eq 0 ]
[ -s "osint/github_leaks.json" ]
grep -q "generic-api-key" "osint/github_leaks.json"
}
@test "github_leaks adds --exhaustive flag in DEEP mode" {
mkdir -p osint
export tools="$TEST_DIR/tools"
mkdir -p "$tools/ghleaks"
# Create mock ghleaks that records its arguments
cat > "$tools/ghleaks/ghleaks" <<'SH'
#!/usr/bin/env bash
printf '%s\n' "$@" > /tmp/ghleaks_args.txt
report=""
while [[ $# -gt 0 ]]; do
case "$1" in
--report)
report="$2"
shift 2
;;
*)
shift
;;
esac
done
if [[ -n "$report" ]]; then
printf '%s\n' '{}' > "$report"
fi
SH
chmod +x "$tools/ghleaks/ghleaks"
printf '%s\n' 'ghp_mock_token_12345' > "$TEST_DIR/.github_tokens"
export GITHUB_TOKENS="$TEST_DIR/.github_tokens"
export GITHUB_LEAKS=true
export OSINT=true
export DEEP=true
export GHLEAKS_THREADS=2
run github_leaks
[ "$status" -eq 0 ]
grep -q "\-\-exhaustive" /tmp/ghleaks_args.txt
rm -f /tmp/ghleaks_args.txt
}
@test "service_fingerprint writes nerva artifacts from naabu input" {
mkdir -p hosts .tmp
printf '%s\n' '10.10.10.10:22' > hosts/naabu_open.txt
cat > "$MOCK_BIN/nerva" <<'SH'
#!/usr/bin/env bash
outfile=""
while [[ $# -gt 0 ]]; do
case "$1" in
-o)
outfile="$2"
shift 2
;;
*)
shift
;;
esac
done
printf '%s\n' '{"host":"10.10.10.10","port":22,"protocol":"ssh"}' > "$outfile"
SH
chmod +x "$MOCK_BIN/nerva"
export SERVICE_FINGERPRINT=true
export SERVICE_FINGERPRINT_ENGINE="nerva"
export SERVICE_FINGERPRINT_TIMEOUT_MS=500
export AXIOM=false
run service_fingerprint
[ "$status" -eq 0 ]
[ -s "hosts/service_fingerprints.jsonl" ]
[ -s "hosts/service_fingerprints.txt" ]
grep -q "10.10.10.10:22" "hosts/service_fingerprints.txt"
}
@test "spraying supports brutus engine with service fingerprint json input" {
mkdir -p hosts vulns .tmp
printf '%s\n' 'Host: 10.10.10.10 () Ports: 22/open/tcp//ssh///' > hosts/portscan_active.gnmap
printf '%s\n' '{"host":"10.10.10.10","port":22,"protocol":"ssh"}' > hosts/service_fingerprints.jsonl
cat > "$MOCK_BIN/brutus" <<'SH'
#!/usr/bin/env bash
outfile=""
while [[ $# -gt 0 ]]; do
case "$1" in
-o)
outfile="$2"
shift 2
;;
*)
shift
;;
esac
done
cat >/dev/null
printf '%s\n' '{"protocol":"ssh","target":"10.10.10.10:22","username":"root","password":"toor"}' > "$outfile"
SH
chmod +x "$MOCK_BIN/brutus"
export SPRAY=true
export SPRAY_ENGINE="brutus"
export SPRAY_BRUTUS_ONLY_DEEP=false
export DEEP=false
run spraying
[ "$status" -eq 0 ]
[ -s "vulns/brutus.jsonl" ]
grep -q "10.10.10.10:22" "vulns/brutus.jsonl"
}
@test "llm_probe writes julius jsonl output" {
mkdir -p webs .tmp
printf '%s\n' 'https://llm.target.example.com' > webs/webs_all.txt
cat > "$MOCK_BIN/julius" <<'SH'
#!/usr/bin/env bash
printf '%s\n' '{"target":"https://llm.target.example.com","provider":"openai-compatible","probe":"chat-completions"}'
SH
chmod +x "$MOCK_BIN/julius"
export LLM_PROBE=true
export LLM_PROBE_AUGUSTUS=false
run llm_probe
[ "$status" -eq 0 ]
[ -s "webs/llm_probe.jsonl" ]
[ -s "webs/llm_probe.txt" ]
grep -q "openai-compatible" "webs/llm_probe.txt"
}
@test "param_discovery skips in non-deep mode" {
mkdir -p webs .tmp
printf '%s\n' 'https://target.example.com/path' > webs/url_extract_nodupes.txt
cat > "$MOCK_BIN/arjun" <<'SH'
#!/usr/bin/env bash
exit 0
SH
chmod +x "$MOCK_BIN/arjun"
export DEEP=false
export PARAM_DISCOVERY=true
export ARJUN_THREADS=5
run param_discovery
[ "$status" -eq 0 ]
[[ "$output" == *"SKIP"* ]]
}
@test "param_discovery runs in deep mode with arjun text output" {
mkdir -p webs .tmp
printf '%s\n' 'https://target.example.com/path' > webs/url_extract_nodupes.txt
cat > "$MOCK_BIN/arjun" <<'SH'
#!/usr/bin/env bash
outfile=""
while [[ $# -gt 0 ]]; do
case "$1" in
-oT)
outfile="$2"
shift 2
;;
*)
shift
;;
esac
done
printf '%s\n' 'http://testaspnet.vulnweb.com/login.aspx?__VIEWSTATE=3698&token=abc' > "$outfile"
exit 0
SH
chmod +x "$MOCK_BIN/arjun"
export DEEP=true
export AXIOM=false
export PARAM_DISCOVERY=true
export ARJUN_THREADS=5
run param_discovery
[ "$status" -eq 0 ]
[ -s "webs/params_discovered.txt" ]
grep -q "URL: http://testaspnet.vulnweb.com/login.aspx?__VIEWSTATE=3698&token=abc" "webs/params_discovered.txt"
grep -q "PARAM: __VIEWSTATE" "webs/params_discovered.txt"
grep -q "PARAM: token" "webs/params_discovered.txt"
}
@test "well_known_pivots probes newly discovered subdomains into webs.txt" {
mkdir -p webs .tmp subdomains
printf '%s\n' 'https://target.example.com' > webs/webs_all.txt
_resolve_domains() {
cat "$1" > "$2"
}
cat > "$MOCK_BIN/curl" <<'SH'
#!/usr/bin/env bash
url="${@: -1}"
case "$url" in
*"/.well-known/security.txt"|*"/security.txt")
printf '%s\n' 'Contact: [email protected]'
;;
*)
printf '%s\n' ''
;;
esac
SH
chmod +x "$MOCK_BIN/curl"
cat > "$MOCK_BIN/httpx" <<'SH'
#!/usr/bin/env bash
while IFS= read -r host; do
[[ -z "$host" ]] && continue
printf '%s [200]\n' "https://${host}"
done
SH
chmod +x "$MOCK_BIN/httpx"
export WELLKNOWN_PIVOTS=true
export HTTPX_THREADS=5
export HTTPX_RATELIMIT=0
export HTTPX_TIMEOUT=5
run well_known_pivots
[ "$status" -eq 0 ]
[ -s "subdomains/subdomains.txt" ]
[ -s "webs/webs.txt" ]
grep -q '^auth.target.example.com$' "subdomains/subdomains.txt"
grep -q '^https://auth.target.example.com$' "webs/webs.txt"
}
@test "wordlist_gen_roboxtractor skips in non-DEEP mode with explicit mode reason" {
mkdir -p webs .tmp gf
printf '%s\n' 'https://target.example.com' > webs/webs_all.txt
export ROBOTSWORDLIST=true
export DEEP=false
run wordlist_gen_roboxtractor
[ "$status" -eq 0 ]
[[ "$output" == *"SKIP"* ]]
[[ "$output" == *"reason: mode"* ]]
[ -f "$called_fn_dir/.skip_wordlist_gen_roboxtractor" ]
[ -f "$called_fn_dir/.status_reason_wordlist_gen_roboxtractor" ]
[ "$(cat "$called_fn_dir/.status_reason_wordlist_gen_roboxtractor")" = "mode" ]
}
@test "wordlist_gen_roboxtractor runs in DEEP mode and writes robots wordlist" {
mkdir -p webs .tmp gf
printf '%s\n' 'https://target.example.com' > webs/webs_all.txt
cat > "$MOCK_BIN/roboxtractor" <<'SH'
#!/usr/bin/env bash
while IFS= read -r url; do
[[ -z "$url" ]] && continue
printf '%s/robots-path\n' "${url%/}"
done
SH
chmod +x "$MOCK_BIN/roboxtractor"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
quiet=false
if [[ "${1:-}" == "-q" ]]; then
quiet=true
shift
fi
outfile="$1"
touch "$outfile"
while IFS= read -r line; do
[[ -z "$line" ]] && continue
if ! grep -Fxq -- "$line" "$outfile"; then
printf '%s\n' "$line" >> "$outfile"
if [[ "$quiet" != true ]]; then
printf '%s\n' "$line"
fi
fi
done
exit 0
SH
chmod +x "$MOCK_BIN/anew"
export ROBOTSWORDLIST=true
export DEEP=true
export PROXY=false
run wordlist_gen_roboxtractor
[ "$status" -eq 0 ]
[ -s "webs/robots_wordlist.txt" ]
grep -q "https://target.example.com/robots-path" "webs/robots_wordlist.txt"
}
# ── swagger_check (sj) tests ──────────────────────────────────────────
@test "swagger_check discovers swagger via sj brute and writes swagger_urls.txt" {
mkdir -p webs .tmp
printf '%s\n' 'https://target.example.com' > webs/webs_all.txt
cat > "$MOCK_BIN/sj" <<'SH'
#!/usr/bin/env bash
if [[ "$1" == "brute" ]]; then
printf '%s\n' 'Definition file found: https://target.example.com/swagger.json'
fi
SH
chmod +x "$MOCK_BIN/sj"
cat > "$MOCK_BIN/interlace" <<'SH'
#!/usr/bin/env bash
targets="" cmd="" outdir=""
while [[ $# -gt 0 ]]; do
case "$1" in
-tL) targets="$2"; shift 2 ;;
-c) cmd="$2"; shift 2 ;;
-o) outdir="$2"; shift 2 ;;
*) shift ;;
esac
done
mkdir -p "$outdir"
while IFS= read -r target; do
clean=$(echo "$target" | sed 's|[^a-zA-Z0-9._-]|_|g')
real_cmd=$(echo "$cmd" | sed "s|_target_|$target|g" | sed "s|_output_|$outdir|g" | sed "s|_cleantarget_|$clean|g")
eval "$real_cmd"
done < "$targets"
SH
chmod +x "$MOCK_BIN/interlace"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
if [[ "$1" == "-q" ]]; then
target="$2"
else
target="$1"
fi
while IFS= read -r line; do
if [[ -n "$target" ]]; then
printf '%s\n' "$line" >> "$target"
else
printf '%s\n' "$line"
fi
done
SH
chmod +x "$MOCK_BIN/anew"
export SJ_CHECK=true
export SJ_BRUTE=true
export SJ_AUTOMATE=false
export SJ_TIMEOUT=10
export SJ_MAX_TARGETS=100
export INTERLACE_THREADS=1
export NUCLEI_SEVERITY="info"
export DIFF=false
run swagger_check
[ "$status" -eq 0 ]
[ -s "webs/swagger_urls.txt" ]
grep -q "target.example.com/swagger.json" "webs/swagger_urls.txt"
}
@test "swagger_check aggregates nuclei swagger-api findings" {
mkdir -p webs .tmp nuclei_output
cat > "$MOCK_BIN/sj" <<'SH'
#!/usr/bin/env bash
exit 0
SH
chmod +x "$MOCK_BIN/sj"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
if [[ "$1" == "-q" ]]; then
target="$2"
else
target="$1"
fi
while IFS= read -r line; do
if [[ -n "$target" ]]; then
printf '%s\n' "$line" >> "$target"
else
printf '%s\n' "$line"
fi
done
SH
chmod +x "$MOCK_BIN/anew"
# Nuclei output with swagger-api finding
printf '%s\n' '{"template-id":"swagger-api","matched-at":"https://target.example.com/v2/swagger.json","info":{"severity":"info"}}' \
> nuclei_output/info_json.txt
export SJ_CHECK=true
export SJ_BRUTE=false
export SJ_AUTOMATE=false
export SJ_TIMEOUT=10
export NUCLEI_SEVERITY="info"
export DIFF=false
run swagger_check
[ "$status" -eq 0 ]
[ -s "webs/swagger_urls.txt" ]
grep -q "target.example.com/v2/swagger.json" "webs/swagger_urls.txt"
}
@test "swagger_check runs sj automate and extracts accessible endpoints" {
mkdir -p webs .tmp vulns/swagger/automate
printf '%s\n' 'https://target.example.com/swagger.json' > .tmp/swagger_urls_all.txt
printf '%s\n' 'https://target.example.com/swagger.json' > webs/swagger_urls.txt
cat > "$MOCK_BIN/sj" <<'SH'
#!/usr/bin/env bash
if [[ "$1" == "endpoints" ]]; then
printf '%s\n' '/api/v1/users' '/api/v1/pets'
elif [[ "$1" == "automate" ]]; then
outfile=""
for arg in "$@"; do
case "$prev" in
-o) outfile="$arg" ;;
esac
prev="$arg"
done
if [[ -n "$outfile" ]]; then
printf '%s\n' '{"method":"GET","status":200,"target":"/api/v1/users"}' > "$outfile"
printf '%s\n' '{"method":"POST","status":401,"target":"/api/v1/pets"}' >> "$outfile"
fi
fi
SH
chmod +x "$MOCK_BIN/sj"
cat > "$MOCK_BIN/anew" <<'SH'
#!/usr/bin/env bash
if [[ "$1" == "-q" ]]; then
target="$2"
else
target="$1"
fi
while IFS= read -r line; do
if [[ -n "$target" ]]; then
printf '%s\n' "$line" >> "$target"
else
printf '%s\n' "$line"
fi
done
SH
chmod +x "$MOCK_BIN/anew"
export SJ_CHECK=true
export SJ_BRUTE=false
export SJ_AUTOMATE=true
export SJ_TIMEOUT=10
export NUCLEI_SEVERITY="info"
export DIFF=false
run swagger_check
[ "$status" -eq 0 ]
[ -s "vulns/swagger/endpoints_all.txt" ]
grep -q "/api/v1/users" "vulns/swagger/endpoints_all.txt"
[ -s "vulns/swagger/accessible_endpoints.txt" ]
grep -q "GET /api/v1/users" "vulns/swagger/accessible_endpoints.txt"
# 401 endpoint should NOT be in accessible list
! grep -q "/api/v1/pets" "vulns/swagger/accessible_endpoints.txt"
}
@test "swagger_check skips when SJ_CHECK=false" {
mkdir -p webs .tmp
export SJ_CHECK=false
run swagger_check
[ "$status" -eq 0 ]
[ ! -f "webs/swagger_urls.txt" ]
}