429 lines
16 KiB
Bash
429 lines
16 KiB
Bash
#!/usr/bin/env bash
|
|
# ------------------------------------------------------------------------------
|
|
# Copyright (c) 2013-2026 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
|
|
# Protected by the BSD3 license. Please read bellow for details.
|
|
#
|
|
# * Redistribution and use in source and binary forms,
|
|
# * with or without modification, are permitted provided
|
|
# * that the following conditions are met:
|
|
# *
|
|
# * Redistributions of source code must retain the above
|
|
# * copyright notice, this list of conditions and the
|
|
# * following disclaimer.
|
|
# *
|
|
# * Redistributions in binary form must reproduce the above
|
|
# * copyright notice, this list of conditions and the following
|
|
# * disclaimer in the documentation and/or other materials
|
|
# * provided with the distribution.
|
|
# *
|
|
# * Neither the name of the copyright holder nor the names
|
|
# * of any other contributors may be used to endorse or
|
|
# * promote products derived from this software without
|
|
# * specific prior written permission.
|
|
# *
|
|
# * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
# * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
# * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
# * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
# * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
# * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
# * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
# * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
# * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
# * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
# * OF SUCH DAMAGE.
|
|
# ------------------------------------------------------------------------------
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Make non-IT peoples think you're busy doing something hard
|
|
# Usage: busy [options] [pattern]
|
|
# Options:
|
|
# --delay=<ms> : add a delay between each line output (milliseconds)
|
|
# pattern : the string to search for in the hexdump output (default is "ca fe")
|
|
busy()
|
|
{
|
|
local pattern="${BUSY_DEFAULT_PATTERN:-ca fe}" delay_ms="${BUSY_DEFAULT_DELAY:-0}"
|
|
|
|
local PARSED
|
|
# Short: h, p:, d:
|
|
# Long: help, pattern:, delay:
|
|
PARSED=$(getopt -o hp:d: --long help,pattern:,delay: -n 'busy' -- "$@")
|
|
# shellcheck disable=SC2181 # getopt return code is checked immediately after
|
|
if [[ $? -ne 0 ]]; then
|
|
disp E "Invalid options, use \"busy --help\" to display usage."
|
|
return 1
|
|
fi
|
|
eval set -- "$PARSED"
|
|
|
|
while true; do
|
|
case "$1" in
|
|
-h|--help)
|
|
printf "busy: Monitor /dev/urandom for a specific pattern.\n\n"
|
|
printf "Usage: busy [options] [pattern]\n\n"
|
|
printf "Options:\n"
|
|
printf "\t-h, --help\t\tDisplay this help screen\n"
|
|
printf "\t-p, --pattern PATTERN\tHex pattern to search (default: \"ca fe\")\n"
|
|
printf "\t-d, --delay MS\t\tDelay between matches in milliseconds\n"
|
|
return 0
|
|
;;
|
|
-p|--pattern)
|
|
pattern="$2"
|
|
shift 2
|
|
;;
|
|
-d|--delay)
|
|
delay_ms="$2"
|
|
if ! [[ "$delay_ms" =~ ^[0-9]+$ ]]; then
|
|
disp E "Invalid delay: must be an integer (milliseconds)."
|
|
return 1
|
|
fi
|
|
shift 2
|
|
;;
|
|
--)
|
|
shift
|
|
break
|
|
;;
|
|
*)
|
|
disp E "Invalid option: $1"
|
|
return 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# Convert milliseconds to seconds for 'sleep'
|
|
local delay_s
|
|
delay_s=$(awk "BEGIN{
|
|
printf \"%.3f\", $delay_ms / 1000 }")
|
|
|
|
# Monitor /dev/urandom
|
|
(
|
|
hexdump -C < /dev/urandom | grep -iF --line-buffered "$pattern" | \
|
|
while read -r line; do
|
|
echo "$line"
|
|
[[ $delay_ms -gt 0 ]] && sleep "$delay_s"
|
|
done
|
|
) & local sub_pid=$!
|
|
|
|
IFS= read -r -n 1 -s _ </dev/tty
|
|
kill -- -"$sub_pid" 2>/dev/null || kill "$sub_pid" 2>/dev/null
|
|
wait "$sub_pid" 2>/dev/null
|
|
return 0
|
|
}
|
|
# ------------------------------------------------------------------------------
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Simulate a long and complex compilation process
|
|
# Usage: fake_compile [options]
|
|
# Options:
|
|
# --delay=<ms> : delay between output lines (milliseconds, default: 80)
|
|
# --lang=<lang> : source language preset: c (default), cpp, java, python
|
|
# --errors : inject fake compilation errors at the end of the build
|
|
fake_compile()
|
|
{
|
|
local delay_ms="${FAKE_COMPILE_DEFAULT_DELAY:-80}" lang="c" with_errors=0
|
|
|
|
local PARSED
|
|
# Short: h, d:, l:, e
|
|
# Long: help, delay:, lang:, errors
|
|
PARSED=$(getopt -o hd:l:e --long help,delay:,lang:,errors -n 'fake_compile' -- "$@")
|
|
# shellcheck disable=SC2181 # getopt return code is checked immediately after
|
|
if [[ $? -ne 0 ]]; then
|
|
disp E "Invalid options, use \"fake_compile --help\" to display usage."
|
|
return 1
|
|
fi
|
|
eval set -- "$PARSED"
|
|
|
|
while true; do
|
|
case "$1" in
|
|
-h|--help)
|
|
printf "fake_compile: Simulate a complex compilation process.\n\n"
|
|
printf "Usage: fake_compile [options]\n\n"
|
|
printf "Options:\n"
|
|
printf "\t-h, --help\t\tDisplay this help screen\n"
|
|
printf "\t-d, --delay MS\t\tDelay between lines in milliseconds (default: 80)\n"
|
|
printf "\t-l, --lang LANG\t\tLanguage preset: c, cpp, java, python (default: c)\n"
|
|
printf "\t-e, --errors\t\tInject fake compilation errors at the end\n"
|
|
return 0
|
|
;;
|
|
-d|--delay)
|
|
delay_ms="$2"
|
|
if ! [[ "$delay_ms" =~ ^[0-9]+$ ]]; then
|
|
disp E "Invalid delay: must be an integer (milliseconds)."
|
|
return 1
|
|
fi
|
|
shift 2
|
|
;;
|
|
-l|--lang)
|
|
lang="$2"
|
|
case "$lang" in
|
|
c|cpp|java|python) ;;
|
|
*)
|
|
disp E "Invalid lang: must be one of: c, cpp, java, python."
|
|
return 1
|
|
;;
|
|
esac
|
|
shift 2
|
|
;;
|
|
-e|--errors)
|
|
with_errors=1
|
|
shift
|
|
;;
|
|
--)
|
|
shift
|
|
break
|
|
;;
|
|
*)
|
|
disp E "Invalid option: $1"
|
|
return 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
local delay_s
|
|
delay_s=$(awk "BEGIN{ printf \"%.3f\", $delay_ms / 1000 }")
|
|
|
|
(
|
|
c_files=( "main" "utils" "parser" "lexer" "codegen" "optimizer"
|
|
"allocator" "scheduler" "resolver" "runtime" "buffer"
|
|
"hashmap" "io" "net" "crypto" "compress" )
|
|
cpp_files=( "Application" "Controller" "AbstractFactory" "Singleton"
|
|
"Observer" "Strategy" "Builder" "Facade" "Proxy"
|
|
"Iterator" "Decorator" "CommandDispatcher" "EventLoop"
|
|
"MemoryPool" "ThreadSafe" )
|
|
java_files=( "Application" "Service" "Repository" "Controller" "Entity"
|
|
"Configuration" "SecurityConfig" "DataSourceConfig"
|
|
"RestTemplate" "ExceptionHandler" "Validator" )
|
|
python_files=( "setup" "config" "utils" "models" "views" "serializers"
|
|
"migrations/0001_initial" "migrations/0002_auto" "tests"
|
|
"signals" "admin" "apps" "urls" "wsgi" "celery" "tasks" )
|
|
|
|
warnings=(
|
|
"warning: implicit declaration of function"
|
|
"warning: unused variable [-Wunused-variable]"
|
|
"warning: comparison between signed and unsigned integer expressions"
|
|
"warning: suggest parentheses around operand of '!'"
|
|
"warning: format '%d' expects 'int', but argument has type 'long int'"
|
|
"warning: control reaches end of non-void function [-Wreturn-type]"
|
|
"warning: deprecated conversion from string literal to 'char*'"
|
|
"warning: address of local variable taken"
|
|
)
|
|
errors=(
|
|
"error: 'NULL' was not declared in this scope"
|
|
"error: expected ';' before '}' token"
|
|
"error: undefined reference to 'main'"
|
|
"error: too few arguments to function"
|
|
"error: invalid use of incomplete type"
|
|
)
|
|
|
|
case "$lang" in
|
|
c) files=("${c_files[@]}"); ext=".c" ;;
|
|
cpp) files=("${cpp_files[@]}"); ext=".cpp" ;;
|
|
java) files=("${java_files[@]}"); ext=".java" ;;
|
|
python) files=("${python_files[@]}"); ext=".py" ;;
|
|
esac
|
|
|
|
total=${#files[@]}
|
|
i=0
|
|
for f in "${files[@]}"; do
|
|
i=$(( i + 1 ))
|
|
warn_count=$(( RANDOM % 3 ))
|
|
printf "[ %2d/%2d ] Compiling %s%s ...\n" "$i" "$total" "$f" "$ext"
|
|
sleep "$delay_s"
|
|
w=0
|
|
while [[ $w -lt $warn_count ]]; do
|
|
wline="${warnings[$((RANDOM % ${#warnings[@]}))]}"
|
|
printf " %s%s:%d:%d: %s\n" \
|
|
"$f" "$ext" "$(( RANDOM % 200 + 1 ))" "$(( RANDOM % 80 + 1 ))" "$wline"
|
|
sleep "$delay_s"
|
|
w=$(( w + 1 ))
|
|
done
|
|
done
|
|
|
|
if [[ $with_errors -eq 1 ]]; then
|
|
for eline in "${errors[@]}"; do
|
|
ef="${files[$((RANDOM % ${#files[@]}))]}"
|
|
printf " %s%s:%d:%d: %s\n" \
|
|
"$ef" "$ext" "$(( RANDOM % 200 + 1 ))" "$(( RANDOM % 80 + 1 ))" "$eline"
|
|
sleep "$delay_s"
|
|
done
|
|
printf "\nBuild FAILED: %d error(s), %d warning(s)\n" \
|
|
"${#errors[@]}" "$(( RANDOM % 20 + 5 ))"
|
|
else
|
|
printf "\nBuild SUCCEEDED: 0 error(s), %d warning(s)\n" \
|
|
"$(( RANDOM % 15 + 2 ))"
|
|
fi
|
|
) & local sub_pid=$!
|
|
|
|
IFS= read -r -n 1 -s _ </dev/tty
|
|
kill -- -"$sub_pid" 2>/dev/null || kill "$sub_pid" 2>/dev/null
|
|
wait "$sub_pid" 2>/dev/null
|
|
return 0
|
|
}
|
|
# ------------------------------------------------------------------------------
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Simulate a dramatic hacking sequence
|
|
# Usage: hack [options]
|
|
# Options:
|
|
# --target=<ip> : target IP address (default: random)
|
|
# --delay=<ms> : delay between output lines (milliseconds, default: 120)
|
|
hack()
|
|
{
|
|
local delay_ms="${HACK_DEFAULT_DELAY:-120}" target=""
|
|
|
|
local PARSED
|
|
# Short: h, t:, d:
|
|
# Long: help, target:, delay:
|
|
PARSED=$(getopt -o ht:d: --long help,target:,delay: -n 'hack' -- "$@")
|
|
# shellcheck disable=SC2181 # getopt return code is checked immediately after
|
|
if [[ $? -ne 0 ]]; then
|
|
disp E "Invalid options, use \"hack --help\" to display usage."
|
|
return 1
|
|
fi
|
|
eval set -- "$PARSED"
|
|
|
|
while true; do
|
|
case "$1" in
|
|
-h|--help)
|
|
printf "hack: Simulate a dramatic hacking sequence.\n\n"
|
|
printf "Usage: hack [options]\n\n"
|
|
printf "Options:\n"
|
|
printf "\t-h, --help\t\tDisplay this help screen\n"
|
|
printf "\t-t, --target IP\t\tTarget IP address (default: random)\n"
|
|
printf "\t-d, --delay MS\t\tDelay between output lines in milliseconds (default: 120)\n"
|
|
return 0
|
|
;;
|
|
-t|--target)
|
|
target="$2"
|
|
shift 2
|
|
;;
|
|
-d|--delay)
|
|
delay_ms="$2"
|
|
if ! [[ "$delay_ms" =~ ^[0-9]+$ ]]; then
|
|
disp E "Invalid delay: must be an integer (milliseconds)."
|
|
return 1
|
|
fi
|
|
shift 2
|
|
;;
|
|
--)
|
|
shift
|
|
break
|
|
;;
|
|
*)
|
|
disp E "Invalid option: $1"
|
|
return 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
local delay_s
|
|
delay_s=$(awk "BEGIN{ printf \"%.3f\", $delay_ms / 1000 }")
|
|
|
|
(
|
|
rand_ip() { printf '%d.%d.%d.%d\n' \
|
|
$(( RANDOM%223+1 )) $(( RANDOM%255 )) \
|
|
$(( RANDOM%255 )) $(( RANDOM%254+1 )); }
|
|
rand_mac() { printf '%02x:%02x:%02x:%02x:%02x:%02x\n' \
|
|
$(( RANDOM%256 )) $(( RANDOM%256 )) $(( RANDOM%256 )) \
|
|
$(( RANDOM%256 )) $(( RANDOM%256 )) $(( RANDOM%256 )); }
|
|
rand_hash() { printf '%04x%04x%04x%04x%04x%04x%04x%04x' \
|
|
$RANDOM $RANDOM $RANDOM $RANDOM \
|
|
$RANDOM $RANDOM $RANDOM $RANDOM; }
|
|
|
|
[[ -z "$target" ]] && target="$(rand_ip)"
|
|
|
|
ports=( 22 80 443 3306 5432 6379 8080 8443 27017 )
|
|
services=( "ssh" "http" "https" "mysql" "postgresql" "redis" "http-alt" "https-alt" "mongodb" )
|
|
cve_ids=( "CVE-2024-3094" "CVE-2023-44487" "CVE-2024-6387" "CVE-2021-44228" "CVE-2022-0847" )
|
|
os_list=( "Linux 5.15.x" "Linux 6.1.x" "Ubuntu 22.04 LTS" "Debian 12" "CentOS Stream 9" )
|
|
users=( "root" "admin" "www-data" "postgres" "redis" "deploy" )
|
|
passwords=( "password123" "admin2024" "letmein!" "Sup3rS3cr3t" "qwerty" "123456" )
|
|
|
|
printf "[*] Initializing attack sequence against %s\n" "$target"
|
|
sleep "$delay_s"
|
|
|
|
# Phase 1 — port scan
|
|
printf "[*] Starting port scan...\n"
|
|
sleep "$delay_s"
|
|
open_ports=()
|
|
for idx in "${!ports[@]}"; do
|
|
if (( RANDOM % 3 != 0 )); then
|
|
printf " %-6s open %s\n" "${ports[$idx]}/tcp" "${services[$idx]}"
|
|
open_ports+=( "${ports[$idx]}/${services[$idx]}" )
|
|
sleep "$delay_s"
|
|
fi
|
|
done
|
|
printf "[+] %d open port(s) found.\n" "${#open_ports[@]}"
|
|
sleep "$delay_s"
|
|
|
|
# Phase 2 — OS fingerprinting
|
|
printf "[*] OS fingerprinting...\n"
|
|
sleep "$delay_s"
|
|
printf "[+] Target OS: %s (MAC: %s)\n" \
|
|
"${os_list[$((RANDOM % ${#os_list[@]}))]}" "$(rand_mac)"
|
|
sleep "$delay_s"
|
|
|
|
# Phase 3 — CVE check
|
|
printf "[*] Checking known vulnerabilities...\n"
|
|
sleep "$delay_s"
|
|
vuln_count=$(( RANDOM % 3 + 1 ))
|
|
v=0
|
|
while [[ $v -lt $vuln_count ]]; do
|
|
printf "[!] Potential vulnerability: %s\n" "${cve_ids[$((RANDOM % ${#cve_ids[@]}))]}"
|
|
sleep "$delay_s"
|
|
v=$(( v + 1 ))
|
|
done
|
|
|
|
# Phase 4 — exploit
|
|
printf "[*] Loading exploit module...\n"; sleep "$delay_s"
|
|
printf "[*] Bypassing firewall rules...\n"; sleep "$delay_s"
|
|
printf "[*] Injecting payload"
|
|
dots=0
|
|
while [[ $dots -lt 6 ]]; do
|
|
printf "."
|
|
sleep "$(awk "BEGIN{ printf \"%.3f\", $delay_ms * 1.5 / 1000 }")"
|
|
dots=$(( dots + 1 ))
|
|
done
|
|
printf "\n"
|
|
printf "[+] Shell obtained on %s\n" "$target"
|
|
sleep "$delay_s"
|
|
|
|
# Phase 5 — hash dumping
|
|
printf "[*] Dumping password hashes...\n"
|
|
sleep "$delay_s"
|
|
for u in "${users[@]}"; do
|
|
printf " %-12s : \$6\$%s\n" "$u" "$(rand_hash)"
|
|
sleep "$delay_s"
|
|
done
|
|
|
|
# Phase 6 — cracking
|
|
printf "[*] Cracking hashes (wordlist: rockyou.txt)...\n"
|
|
sleep "$delay_s"
|
|
cracked=$(( RANDOM % ${#users[@]} + 1 ))
|
|
c=0
|
|
while [[ $c -lt $cracked ]]; do
|
|
printf "[+] Cracked: %-12s -> %s\n" \
|
|
"${users[$c]}" "${passwords[$((RANDOM % ${#passwords[@]}))]}"
|
|
sleep "$delay_s"
|
|
c=$(( c + 1 ))
|
|
done
|
|
|
|
printf "\n[+] -------- ACCESS GRANTED -------- [+]\n"
|
|
printf "[*] Cleaning logs on %s...\n" "$target"
|
|
sleep "$delay_s"
|
|
printf "[+] Done. Have a nice day.\n"
|
|
) & local sub_pid=$!
|
|
|
|
IFS= read -r -n 1 -s _ </dev/tty
|
|
kill -- -"$sub_pid" 2>/dev/null || kill "$sub_pid" 2>/dev/null
|
|
wait "$sub_pid" 2>/dev/null
|
|
return 0
|
|
}
|
|
# ------------------------------------------------------------------------------
|
|
|
|
|
|
load_conf "fun"
|
|
|
|
# EOF
|