.dockerfunc

DOCKER_REPO_PREFIX="s2e"

# Helpers

docker_cleanup(){
        local containers
        mapfile -t containers < <(docker ps -aq 2>/dev/null)
        docker rm "${containers[@]}" 2>/dev/null
        local volumes
        mapfile -t volumes < <(docker ps --filter status=exited -q 2>/dev/null)
        docker rm -v "${volumes[@]}" 2>/dev/null
        local images
        mapfile -t images < <(docker images --filter dangling=true -q 2>/dev/null)
        docker rmi "${images[@]}" 2>/dev/null
}

docker_del_stopped(){
        local name=$1
        local state
        state=$(docker inspect --format "{{.State.Running}}" "$name" 2>/dev/null)

        if [[ "$state" == "false" ]]; then
                docker rm "$name"
        else
            if [[ "$state" == "true" ]]; then
                echo "The container name \"${name}\" is already in use. Would you like to kill the current container and start a new one?"
                PS3='Pick a number: '
                options=("yes" "no")
                select opt in "${options[@]}"; do
                    case $opt in
                        "yes")
                            echo "Stopping Container Now"
                            docker_stop_and_delete "${name}"
                            break
                            ;;
                        "no")
                            echo "We can't start two instances of a docker container. Exiting..."
                            return
                            break
                            ;;
                        *) echo "Invalid option. Please choose again.";;
                    esac
                done
            fi
        fi
}

docker_stop_and_delete(){
        local name=$1
        local state
        state=$(docker inspect --format "{{.State.Running}}" "$name" 2>/dev/null)

        if [[ "$state" == "true" ]]; then
                docker stop "$name"
        fi
        docker_del_stopped "$name"
}


relies_on(){
        for container in "$@"; do
                local state
                state=$(docker inspect --format "{{.State.Running}}" "$container" 2>/dev/null)

                if [[ "$state" == "false" ]] || [[ "$state" == "" ]]; then
                        echo "$container is not running, starting it for you."
                        $container
                fi
        done
}

docker_build_container(){
    local SRC_DIR="${1}"
    local NAME="${2}"
    # Go to source directory
    local DOCKER_REPO_PREFIX="s2e"
    cd "${SRC_DIR}"
    docker build --rm --force-rm -t "${DOCKER_REPO_PREFIX}/${NAME}" .
}


keypassxc(){
        docker_del_stopped keypassxc

        docker run -d \
                -v /etc/localtime:/etc/localtime:ro \
                -v /tmp/.X11-unix:/tmp/.X11-unix \
                -v /usr/share/X11/xkb:/usr/share/X11/xkb:ro \
                -e "DISPLAY=unix${DISPLAY}" \
                -v /etc/machine-id:/etc/machine-id:ro \
                -v $HOME/.config/keepassxc:/root/.config/keepassxc \
                --name keypassxc \
                ${DOCKER_REPO_PREFIX}/keepassxc
}

archive_site() {
      docker_del_stopped sloppy_archivist

      local URL="$1"
      docker run \
      -v ${HOME}/code/sloppy_archivist:/etc/spider \
      -e URL="${URL}" \
      --name sloppy_archivist \
      ${DOCKER_REPO_PREFIX}/sloppy_archivist
}

viper_test() {
        docker_del_stopped viper
        docker -D run \
        -v ~/malware/2018:/malware \
        -v viper_data:/root/.viper \
        -it \
        --name viper \
        ${DOCKER_REPO_PREFIX}/viper \
        bash
}

viper() {
	# change the volume location
        docker_del_stopped viper
        docker run \
        -v /tmp/malware:/home/viper/workdir/malware \
        -v viper_data:/root/.viper \
        -it \
        --name viper \
        ${DOCKER_REPO_PREFIX}/viper
}

viper_reconnect() {
        local last_session=$(docker ps -a -q --filter='ancestor=s2e/viper' | head -n 1)
        if [[ "$last_session" != "" ]]; then
                docker start $last_session
                docker attach $last_session
        fi
}

viper_bash() {
        docker_del_stopped viper-bash
        docker -D run \
        -v ~/malware/2018:/malware \
        -v ~/malware/tools:/tools \
        -v viper_data:/root/.viper \
        -it \
        --name viper-bash \
        ${DOCKER_REPO_PREFIX}/viper \
        bash
}

viper_dev() {
        docker_del_stopped viper-dev
        docker -D run \
        -v ~/malware:/malware \
        -v ~/malware/tools:/tools \
        -v viper_data:/root/.viper \
        -it \
        --name viper-dev \
        ${DOCKER_REPO_PREFIX}/viper_dev \
        bash
}



v2_bash() {
        docker_del_stopped v2-bash
        docker -D run \
        -v ~/malware/2018:/malware \
        -v viper_data:/root/.viper \
        -it \
        --name v2-bash \
        ${DOCKER_REPO_PREFIX}/v2 \
        bash
}

boxjs() {
        docker_del_stopped boxjs

        local tmpdir=$(mktemp -dt "BOX_JS_RESULTS.XXXXX")
        local samples="${tmpdir}/samples/"
        local results="${tmpdir}/results/"
        mkdir -p "${samples}"
        mkdir -p "${results}"
        cp "${1}" "${samples}"

        docker run \
        --rm \
        --volume "${samples}":/samples \
        --volume "${results}":/results \
        --name boxjs \
        s2e/box-js \
        box-js /samples --output-dir=/results --loglevel=debug

        # Get results directory
        cp "${results}" .
}

# maltools() {
#         docker_del_stopped maltools
#        #  docker run --rm -it \
#        #  --security-opt="no-new-privileges" \
#        #  --cap-drop=all \
#        # -v ~/malware:/home/malware \
#        # --name maltools \
#        # ${DOCKER_REPO_PREFIX}/malware-tools
#         docker run --rm -it \
#        -v ~/malware:/home/malware \
#        --name maltools \
#        ${DOCKER_REPO_PREFIX}/malware-tools
# }

harpoon() {
       docker_del_stopped harpoon

       docker run \
       --rm -it \
       --name harpoon \
       -v /tmp/malware:/home/harpoon/malware \
       -v ~/dotfiles/private/harpoon:/home/harpoon/.config/harpoon/ \
       ${DOCKER_REPO_PREFIX}/harpoon
}

harpoon_gpg() {
       docker_del_stopped harpoon

       local config_file="${HOME}/dotfiles/private/harpoon/config.gpg"
       local tmpdir=$(mktemp -dt "$(basename "$0").XXXXX")
       gpg -o "${tmpdir}/config" -d "${config_file}"

       docker run \
       --rm -it \
       --name harpoon \
       -v ~/malware:/home/harpoon/malware \
       -v "${tmpdir}:/home/harpoon/.config/harpoon/" \
       ${DOCKER_REPO_PREFIX}/harpoon

       rm -fr "${tmpdir}"
}

play_docker() {
       docker_del_stopped play

       docker run \
       --rm -it \
       -v /tmp/malware:/home/malware \
       --name play \
       ${DOCKER_REPO_PREFIX}/play bash
}

test_xapp_docker() {
       docker_del_stopped test_xapp
       mkdir -p /tmp/docker_file_transfer

       docker run \
       --rm -it \
       -v /etc/localtime:/etc/localtime:ro \
       -v /tmp/.X11-unix:/tmp/.X11-unix \
       -e "DISPLAY=unix${DISPLAY}" \
       -e GDK_SCALE \
       -e GDK_DPI_SCALE \
       -v /tmp/docker_file_transfer:/home/user/test_files \
       --name test_xapp \
       ${DOCKER_REPO_PREFIX}/play bash
}

cutter() {
       docker_del_stopped cutter

       docker run \
       --rm -it \
       --name cutter \
       ${DOCKER_REPO_PREFIX}/cutter bash
}

decode() {
        docker_del_stopped decode
        docker run \
        --rm \
        -it \
        --name decode \
        ${DOCKER_REPO_PREFIX}/decode \
        dcode -s $1
}

decode_bash() {
        docker_del_stopped decode_bash
        docker run \
        --rm \
        -it \
        --name decode_bash \
        ${DOCKER_REPO_PREFIX}/decode \
        bash
}

cutter() {
     docker_del_stopped cutter
     local CONFDIR="${HOME}/.config/radare2"
     mkdir -p "${CONFDIR}"
     touch ${CONFDIR}/radare2rc
     mkdir -p ${CONFDIR}/r2-config
     xhost +local:docker && \
     docker run \
          --rm \
          -it \
          --name cutter \
          --cap-drop=ALL  \
          --cap-add=SYS_PTRACE \
          -e DISPLAY=$DISPLAY \
          -v /tmp/.X11-unix:/tmp/.X11-unix:ro \
          -v ${HOME}/malware:/var/sharedFolder \
          -v ${CONFDIR}/radare2rc:/home/r2/.radare2rc \
          -v ${CONFDIR}/r2-config:/home/r2/.config/radare2 \
          ${DOCKER_REPO_PREFIX}/cutter
    xhost -local:docker

# --entrypoint "/bin/bash" \
}

cutter_bash() {
     docker_del_stopped cutter
     local CONFDIR="${HOME}/.config/radare2"
     mkdir -p "${CONFDIR}"
     touch ${CONFDIR}/radare2rc
     mkdir -p ${CONFDIR}/r2-config
     xhost +local:docker && \
     docker run \
          --rm \
          -it \
          --name cutter \
          --cap-drop=ALL  \
          --cap-add=SYS_PTRACE \
          -e DISPLAY=$DISPLAY \
          -v /tmp/.X11-unix:/tmp/.X11-unix:ro \
          -v ${HOME}/malware:/var/sharedFolder \
          -v ${CONFDIR}/radare2rc:/home/r2/.radare2rc \
          -v ${CONFDIR}/r2-config:/home/r2/.config/radare2 \
          --entrypoint "/bin/bash" \
           ${DOCKER_REPO_PREFIX}/cutter
    xhost -local:docker
}

cyobstract() {
    docker run --rm -it \
        --net host \
        ${DOCKER_REPO_PREFIX}/cyobstract "$@"
}

thug() {
    docker_del_stopped thug

    local URL="$1"
    if [[ -z "$URL" ]]; then
        echo "Error: You didn't specify a URL"
        printf "Usage:\n\t thug [URL]\n"
    else
        get_new_thug_ua
        docker run \
               -it \
               -v ${HOME}/malware/thug/logs:/home/thug/logs \
               --name thug \
               -e "URL=${URL}" \
               -e "UA=${THUG_UA_STRING}" \
               ${DOCKER_REPO_PREFIX}/thug
        # Save thugs logs to malware folder
        save_thug_logs $1
    fi
}

thug_unassisted() {
    docker_del_stopped thug

    local URL="$1"
    if [[ -z "$URL" ]]; then
        echo "Error: You didn't specify a URL"
        printf "Usage:\n\t thug [URL]\n"
    else
        get_new_thug_ua
        docker run \
               -v ${HOME}/malware/thug/logs:/home/thug/logs \
               --name thug \
               -e "URL=${URL}" \
               -e "UA=${THUG_UA_STRING}" \
               ${DOCKER_REPO_PREFIX}/thug
        # Save thugs logs to malware folder
        save_thug_logs $1
    fi
}


save_thug_logs() {
    local URL="$1"
    local tmpdir=$(mktemp -dt "$(basename "$0").XXXXX")
    local image=$(docker ps -l --format "{{.ID}}")
    local DATE=`date '+%Y-%m'`
    local output_path="${HOME}/malware/thug/logs/${DATE}"
    mkdir -p "${output_path}"
    docker cp "${image}:/tmp/thug/logs/." "${tmpdir}"
    local path=$(find "$tmpdir/" -maxdepth 1 -mindepth 1 -type d)
    local dirname=${path##*/}
    cp -fr "${path}" "${output_path}/${dirname##*/}"
    echo "Thug Output Path: ${output_path}/${dirname}"
    echo "${dirname},${THUG_UA_STRING},${URL}" | tee -a "${output_path}/thug.csv"
}

get_new_thug_ua() {
    useragents=(
            "winxpie60" \
            "winxpie61" \
            "winxpie70" \
            "winxpie80" \
            "winxpchrome20" \
            "winxpfirefox12" \
            "winxpsafari5" \
            "win2kie60" \
            "win2kie80" \
            "win7ie80" \
            "win7ie90" \
            "win7ie100" \
            "win7chrome20" \
            "win7chrome40" \
            "win7chrome45" \
            "win7chrome49" \
            "win7firefox3" \
            "win7safari5" \
            "win10ie110" \
            "osx10chrome19" \
            "osx10safari5" \
            "linuxchrome26" \
            "linuxchrome30" \
            "linuxchrome44" \
            "linuxchrome54" \
            "linuxfirefox19" \
            "linuxfirefox40" \
            "galaxy2chrome18" \
            "galaxy2chrome25" \
            "galaxy2chrome29" \
            "nexuschrome18" \
            "ipadchrome33" \
            "ipadchrome35" \
            "ipadchrome37" \
            "ipadchrome38" \
            "ipadchrome39" \
            "ipadchrome45" \
            "ipadchrome46" \
            "ipadchrome47" \
            "ipadsafari7" \
            "ipadsafari8" \
            "ipadsafari9" \
            )

    THUG_UA_STRING=${useragents[$RANDOM % ${#useragents[@]} ]}
}

thug_bash() {
       local instruction_output_path="$1"
       echo "PATH"
       echo "$instruction_output_path"

       docker_del_stopped thug_bash
       echo "Because you always forget the flags"
       echo "thug -FZM [URL]"
       echo "==================================="
       docker run \
              -it \
              --name thug_bash \
              ${DOCKER_REPO_PREFIX}/thug \
              bash
       echo "PATH"
       echo "$instruction_output_path"
       if [[ -z "$instruction_output_path" ]]; then
           local getem=$(printf "No\nYes" | dmenu -p "do you want your logs?" -l 3)
       fi
       if [[ "Yes" == "${getem}" ]]; then
           if [[ -z "$instruction_output_path" ]]; then
               local DATE=`date '+%Y-%m-%d_%H-%M-%S'`
               local instruction_output_path="${HOME}/malware/thug/logs/${DATE}"
           fi
           local image=$(docker ps -l --format "{{.ID}}")
           # local image=$(docker ps --last 10 -a --format "{{.Names}}::{{.Image}}" | dmenu -l 21 -p "Please choose the name of the thug image to pull from"|cut -d : -f 1)
          docker cp "${image}:/tmp/thug/logs/" "$instruction_output_path"
       fi
}

skype(){
        docker_del_stopped skype
        relies_on pulseaudio

        docker run -d \
                -v /etc/localtime:/etc/localtime:ro \
                -v /tmp/.X11-unix:/tmp/.X11-unix \
                -e "DISPLAY=unix${DISPLAY}" \
                --link pulseaudio:pulseaudio \
                -e PULSE_SERVER=pulseaudio \
                --security-opt seccomp:unconfined \
                --device /dev/video0 \
                --group-add video \
                --group-add audio \
                --name skype \
                ${DOCKER_REPO_PREFIX}/skype
}

wireshark(){
        docker_del_stopped wireshark

        docker run -d \
                -v /etc/localtime:/etc/localtime:ro \
                -v /tmp/.X11-unix:/tmp/.X11-unix \
                -e "DISPLAY=unix${DISPLAY}" \
                --cap-add NET_RAW \
                --cap-add NET_ADMIN \
                --net host \
                --name wireshark \
                ${DOCKER_REPO_PREFIX}/wireshark
}

#nmap(){
#        docker run --rm -it \
#                --net host \
#                ${DOCKER_REPO_PREFIX}/nmap "$@"
#}

slack(){
        docker_del_stopped slack

        docker run -d \
                -v /etc/localtime:/etc/localtime:ro \
                -v /tmp/.X11-unix:/tmp/.X11-unix \
                -e "DISPLAY=unix${DISPLAY}" \
                --device /dev/snd \
                --device /dev/dri \
                --device /dev/video0 \
                --group-add audio \
                --group-add video \
                -v "${HOME}/.slack:/root/.config/Slack" \
                --ipc="host" \
                --name slack \
                ${DOCKER_REPO_PREFIX}/slack "$@"
}

libreoffice(){
        docker_del_stopped libreoffice

        docker run -d \
                -v /etc/localtime:/etc/localtime:ro \
                -v /tmp/.X11-unix:/tmp/.X11-unix \
                -e "DISPLAY=unix${DISPLAY}" \
                -v "${HOME}/slides:/root/slides" \
                -e GDK_SCALE \
                -e GDK_DPI_SCALE \
                --name libreoffice \
                ${DOCKER_REPO_PREFIX}/libreoffice
}

inkscape(){
        docker_del_stopped inkscape
        # xhost +local:docker && \
        docker run -d \
                -v /etc/localtime:/etc/localtime:ro \
                -v /tmp/.X11-unix:/tmp/.X11-unix \
                -e "DISPLAY=unix${DISPLAY}" \
                -v "${HOME}/Pictures:/root/Pictures" \
                -e GDK_SCALE \
                -e GDK_DPI_SCALE \
                --name inkscape \
                ${DOCKER_REPO_PREFIX}/inkscape
        #xhost -local:docker
}


streisand() {
       instruction_output_path="$1"
       docker_del_stopped streisand

       docker run \
       --rm -it \
       --name streisand \
       -v ~/.ssh:/root/.ssh \
       -v ~/home/projects/VPNs:/streisand/generated-docs/ \
       ${DOCKER_REPO_PREFIX}/streisand \
       bash

       # Ask to get streisand output
       local getem=$(printf "No\nYes" | dmenu -p "do you want your logs?" -l 3)
       if [[ "Yes" == "${getem}" ]]; then
          local image=$(docker ps --last 10 -a --format "{{.Names}}::{{.Image}}" | dmenu -l 21 -p "Please choose the name of the streisand image to pull from"|cut -d : -f 1)
          local DATE=`date '+%Y-%m-%d_%H-%M-%S'`
          docker cp "${image}":/streisand/generated-docs/* "$instruction_output_path"

       fi
}



docker-nlp() {
      # Natural Language Processing Play Docker Suite
      local NAME="nlp-bash"
      local SUFFIX="nlp"
        docker_del_stopped "${NAME}"
        docker run \
        --rm \
        -it \
        -v /tmp/malware:/home/user/malware \
        --name "${NAME}" \
        "${DOCKER_REPO_PREFIX}/${SUFFIX}" \
        bash
}

jadx() {
      # JADX
      # https://github.com/samsheff/docker-jadx
      # docker build --rm --force-rm -t "s2e/jadx" .
      local NAME="jadx"
      local SUFFIX="jadx"
        docker_del_stopped "${NAME}"
        docker run \
              -v /tmp/.X11-unix:/tmp/.X11-unix \
               -e "DISPLAY=unix${DISPLAY}" \
               --rm \
               -it \
               -v /tmp/malware:/home/user/workdir/malware \
               --name "${NAME}" \
               "${DOCKER_REPO_PREFIX}/${SUFFIX}"
}

docker-dex2jar() {
      # DEX2JAR
      # https://github.com/yongjhih/docker-dex2jar
      # docker build --rm --force-rm -t "s2e/dex2jar" .
      local NAME="dex2jar-bash"
      local SUFFIX="dex2jar"
        docker_del_stopped "${NAME}"
        docker run \
        --rm \
        -it \
        -v /tmp/malware:/home/viper/workdir/malware \
        --name "${NAME}" \
        "${DOCKER_REPO_PREFIX}/${SUFFIX}" \
        bash
}

docker-apktool() {
      # https://github.com/yongjhih/docker-apktool
      # docker build --rm --force-rm -t "s2e/apktool" .
      local NAME="apktool-bash"
      local SUFFIX="apktool"
        docker_del_stopped "${NAME}"
        docker run \
        --rm \
        -it \
        -v /tmp/malware:/home/viper/workdir/malware \
        --name "${NAME}" \
        "${DOCKER_REPO_PREFIX}/${SUFFIX}" \
        bash
}

is_it_dangerous_bash() {
        docker_del_stopped pycirclean-bash
        docker -D run \
        -v /tmp/malware:/home/viper/workdir/malware \
        -it \
        --name pycirclean-bash \
        ${DOCKER_REPO_PREFIX}/pycirclean \
        bash
}

git-annex(){
        docker_del_stopped git-annex

        # Make annex directory
        sudo mkdir -p "/media/annex"
        enc_volume_path="/media/s2e/annex/library"
        local_path="/media/annex"

        # mount encrypted transfer drive
        sudo veracrypt \
            --text \
            --verbose \
            --protect-hidden=no \
            --pim=0 \
            --keyfiles="" \
            --fs-options="sync" \
            "$enc_volume_path" \
            "$local_path"

        sudo chown -R "$(id -u).$(id -g)" "$local_path"

        docker run --rm -it \
                -v "${HOME}/.gitconfig:/root/.gitconfig" \
                -v "$(pwd):/root/annex" \
                -v "/media/annex:/media/annex" \
                --device /dev/usb \
                --device /dev/bus/usb \
                ${DOCKER_REPO_PREFIX}/git-annex

       # unmount encrypted transfer drive
       sudo veracrypt -d "$local_path"
}

git-annex-bash(){
        docker_del_stopped git-annex

        # Make annex directory
        sudo mkdir -p "/media/annex"
        # Get transfer usb drive by ID
        enc_volume_path="$(for devlink in /dev/disk/by-id/usb-*4C531123631022114023*part*; do readlink -f ${devlink}; done)"
        local_path="/media/annex"

        # mount encrypted transfer drive
        sudo veracrypt \
            --text \
            --verbose \
            --protect-hidden=no \
            --pim=0 \
            --keyfiles="" \
            --fs-options="sync" \
            "$enc_volume_path" \
            "$local_path"

        sudo chown -R "$(id -u).$(id -g)" "$local_path"

        docker run --rm -it \
                -v "${HOME}/.gitconfig:/root/.gitconfig" \
                -v "$(pwd):/root/annex" \
                -v "$local_path:$local_path" \
                --device /dev/usb \
                --device /dev/bus/usb \
                ${DOCKER_REPO_PREFIX}/git-annex bash

       # unmount encrypted transfer drive
       sudo veracrypt -d "$local_path"
}

oletools() {
       docker_del_stopped oletools
       docker -D run \
       -v /tmp/malware:/malware \
       -it \
       --name oletools \
       ${DOCKER_REPO_PREFIX}/oletools \
       bash
}

ooni-run_url() {
       local_url_file=$(readlink -f "${1}")
       docker_del_stopped oonirun
       docker run \
       -v "${local_url_file}:/tmp/local_urls.lsv" \
       -it \
       --rm \
       --name oonirun \
       ${DOCKER_REPO_PREFIX}/oonirun
}

cyberchef() {
       docker_del_stopped cyberchef

       docker run \
       --rm -it \
       -p 8080:8080 \
       --name cyberchef \
       ${DOCKER_REPO_PREFIX}/cyberchef

}

jstillery() {
       docker_del_stopped jstillery

       docker run \
       --rm -it \
       -p 3001:3001 \
       --name jstillery \
       ${DOCKER_REPO_PREFIX}/jstillery
}

cyberchef_bash() {
       docker_del_stopped cyberchef

       docker run \
              --rm -it \
              -p 8080:8080 \
              --name cyberchef \
              ${DOCKER_REPO_PREFIX}/cyberchef bash
}



eyewitness_headless() {
    docker_del_stopped eyewitness
    set -x
    docker run \
           --rm \
           -it \
           --name eyewitness \
           -v /tmp/malware/EyeWitness:/tmp/EyeWitness \
           ${DOCKER_REPO_PREFIX}/eyewitness \
           --web \
           --single "${1}"
}

run_playbook_builder(){
	docker_del_stopped hrwplaybook
	playbook_dir="/tmp/hrw_playbooks"
	rm -fr "${playbook_dir}"
	mkdir -p "${playbook_dir}"
	cp -fr ~/code/Playbooks/static "${playbook_dir}/static"
	docker run \
		-v ~/code/Playbooks:/root/Playbooks \
		-v "${playbook_dir}:/tmp/Playbooks" \
		-it \
		--rm \
		--name hrwplaybook \
	${DOCKER_REPO_PREFIX}/hrwplaybook
	echo "Created playbooks in ${playbook_dir}"
}

# Add private dockerfuncs if they exist
if [ -a "${HOME}/dotfiles/private/.private_dockerfunc" ] ; then
    source "${HOME}/dotfiles/private/.private_dockerfunc"
fi