Quelles bases techniques avant de se lancer en cybersécurité ?

# Navigation et inspection
pwd && ls -la && cd /etc && cat /etc/os-release
 
# Permissions POSIX
chmod 755 script.sh && chown user:group fichier.txt
stat -c '%a %n' /etc/passwd
umask
 
# Recherche et filtrage
find /var/log -name "*.log" -mtime -7
grep -rn "error" /var/log/ | head -20
awk -F: '$3 >= 1000 {print $1, $3}' /etc/passwd
sed 's/foo/bar/g' input.txt > output.txt
 
# Processus et services
ps aux | grep sshd
systemctl status ssh
journalctl -u ssh --since "1 hour ago"
 
# Réseau depuis Linux
ss -tulpn
ip -4 addr show
curl -I https://example.com
dig +short example.com A
 
# Archives et transferts
tar czf backup.tar.gz /home/user/
scp fichier.txt user@host:/tmp/
rsync -av /src/ user@host:/dst/

#!/bin/bash
# Self-test du niveau Linux minimal attendu en pre-preparation
# Usage : bash linux_autotest.sh
 
set -u
tests_passed=0
total_tests=5
 
echo "Test 1 - parsing /etc/passwd (awk)..."
users=$(awk -F: '$3 >= 1000 && $3 < 65000 {print $1}' /etc/passwd | wc -l)
[ "$users" -ge 1 ] && tests_passed=$((tests_passed + 1))
 
echo "Test 2 - interface reseau..."
ip -4 addr show scope global | grep -q 'inet ' && tests_passed=$((tests_passed + 1))
 
echo "Test 3 - lecture logs (journalctl ou syslog)..."
if command -v journalctl > /dev/null; then
  journalctl -n 10 --no-pager > /dev/null 2>&1 && tests_passed=$((tests_passed + 1))
else
  tail -n 10 /var/log/syslog > /dev/null 2>&1 && tests_passed=$((tests_passed + 1))
fi
 
echo "Test 4 - requete HTTP via curl..."
code=$(curl -s -o /dev/null -w "%{http_code}" https://example.com)
[ "$code" = "200" ] && tests_passed=$((tests_passed + 1))
 
echo "Test 5 - lecture permissions octales..."
stat -c '%a' /etc/passwd 2>/dev/null | grep -qE '^6[0-9]{2}$' && tests_passed=$((tests_passed + 1))
 
echo ""
echo "Resultat : $tests_passed / $total_tests tests reussis"
[ "$tests_passed" -eq "$total_tests" ] && echo "Niveau Linux minimal atteint."
[ "$tests_passed" -lt "$total_tests" ] && echo "Reprendre le socle Linux avant formation principale."

# Resolution DNS multi-types
dig +short example.com A
dig +short example.com AAAA
dig +short example.com MX
dig +short example.com TXT
 
# Inspection TLS d'un serveur
openssl s_client -connect example.com:443 -servername example.com < /dev/null 2>/dev/null \
  | grep -E 'subject=|issuer=|Not Before|Not After'
 
# Route reseau vers une cible
traceroute -q 1 example.com 2>/dev/null | head -10
 
# Requete HTTP complete avec headers
curl -sI https://example.com | head -15
 
# Scan de ports basique (uniquement sur sa propre machine)
nmap -sT -p 22,80,443 localhost

"""
Exemple niveau minimal attendu en fin de pre-preparation.
Interrogation API GitHub publique, parsing JSON, persistance JSONL.
"""
import json
import sys
from pathlib import Path
from urllib.request import urlopen, Request
from urllib.error import URLError, HTTPError
 
 
def fetch_github_repos(username: str, max_repos: int = 10) -> list[dict]:
    """Retourne les repos publics d'un utilisateur, jusqu'a max_repos."""
    url = f"https://api.github.com/users/{username}/repos?per_page={max_repos}"
    request = Request(url, headers={"User-Agent": "reconversion-cyber-prereq"})
    try:
        with urlopen(request, timeout=10) as response:
            if response.status != 200:
                raise RuntimeError(f"HTTP {response.status}")
            data = json.loads(response.read())
    except (URLError, HTTPError) as exc:
        print(f"[ERREUR] appel API echoue : {exc}", file=sys.stderr)
        return []
    return [
        {
            "name": repo["name"],
            "stars": repo["stargazers_count"],
            "language": repo.get("language") or "unknown",
        }
        for repo in data
    ]
 
 
def save_repos_jsonl(repos: list[dict], path: Path) -> None:
    """Sauvegarde au format JSON Lines (un objet par ligne)."""
    with path.open("w", encoding="utf-8") as f:
        for r in repos:
            f.write(json.dumps(r, ensure_ascii=False) + "\n")
 
 
if __name__ == "__main__":
    username = sys.argv[1] if len(sys.argv) > 1 else "torvalds"
    output = Path(f"{username}_repos.jsonl")
    repos = fetch_github_repos(username, max_repos=5)
    save_repos_jsonl(repos, output)
    print(f"{len(repos)} repos sauvegardes dans {output}")

#!/bin/bash
# Test de connectivite sur une liste d'hotes, log structure.
# Usage : bash connectivity_check.sh
 
set -euo pipefail
 
LOG_FILE="/tmp/connectivity.log"
HOSTS=("example.com" "google.com" "1.1.1.1")
 
echo "[$(date -Iseconds)] demarrage test connectivite" >> "$LOG_FILE"
 
for host in "${HOSTS[@]}"; do
  if ping -c 1 -W 2 "$host" > /dev/null 2>&1; then
    echo "[$(date -Iseconds)] OK : $host" >> "$LOG_FILE"
  else
    echo "[$(date -Iseconds)] FAIL : $host" >> "$LOG_FILE"
  fi
done
 
echo "[$(date -Iseconds)] termine" >> "$LOG_FILE"
cat "$LOG_FILE" | tail -10

# Configuration initiale (a faire une fois)
git config --global user.name "Prenom Nom"
git config --global user.email "email@domaine.fr"
git config --global init.defaultBranch main
 
# Workflow quotidien
git init
git clone https://github.com/user/repo.git
git add fichier.py
git commit -m "feat: ajout parseur logs"
git push origin main
 
# Branche et merge
git checkout -b feature/nouveau-parseur
# modifications locales
git add . && git commit -m "feat: parseur initial"
git checkout main
git merge feature/nouveau-parseur
git branch -d feature/nouveau-parseur
 
# Resolution d'un conflit (une fois en entretien)
# Apres un git merge conflictuel, ouvrir le fichier affecte,
# reperer les marqueurs <<<<<<<, =======, >>>>>>>
# editer a la main, puis :
git add fichier_conflit.py
git commit -m "fix: resolution conflit parseur"

plan_pre_preparation:
  profil: "reconversion totale, aucun bagage IT"
  duree_totale_mois: 4
  heures_hebdo: 10
  heures_totales_cumulees: 160
 
  mois_1_socle_linux:
    semaine_1:
      - "Linux Journey modules 1-5 (navigation, permissions, texte)"
      - "OverTheWire Bandit niveaux 0-5"
    semaine_4:
      - "OverTheWire Bandit niveaux 15-20"
      - "auto-test Linux (script de la section 2)"
    livrable_fin_mois: "50 commandes Linux automatiques, 5/5 au self-test"
 
  mois_2_socle_reseau:
    - "TryHackMe Pre Security, section Networking"
    - "maniement dig, openssl s_client, curl"
    - "modele OSI et handshake TCP/TLS explicables a haute voix"
    livrable_fin_mois: "trajet d'un paquet HTTPS explique de bout en bout"
 
  mois_3_socle_programmation:
    - "docs.python.org tutoriel chapitres 1-9"
    - "3 scripts Python : fichier, API, JSON"
    - "3 scripts Bash : boucle, condition, pipe"
    livrable_fin_mois: "6 scripts personnels sur GitHub public"
 
  mois_4_consolidation:
    - "git init + branch + merge + resolution conflit"
    - "VirtualBox ou UTM avec Kali Linux et Ubuntu Server"
    - "projet croise : script Python deploye sur VM via SSH"
    livrable_fin_mois: "projet complet demontrable en entretien"
 
  critere_passage_formation:
    - "self-test Linux 5/5"
    - "script Python API fonctionnel sans aide"
    - "VM Kali operationnelle et accessible en SSH"
    - "5+ commits GitHub publics etales sur 4 semaines"

autotest_socle_technique:
 
  linux:
    - "Je connais les 15-20 commandes Linux les plus courantes par automatisme."
    - "Je sais lire 'ps aux' et identifier un processus anormal en production."
    - "Je sais naviguer /var/log et filtrer journalctl par unite et periode."
 
  reseau:
    - "Je peux expliquer le handshake TCP three-way a l'oral en 2 minutes."
    - "Je comprends ce que fait 'dig +short example.com MX' et pourquoi le resultat."
 
  programmation:
    - "J'ai ecrit un script Python qui interroge une API REST sans aide."
    - "J'ai ecrit un script Bash avec boucle, condition et gestion d'erreurs."
 
  git:
    - "J'ai cree un depot git public avec 10+ commits reels etales dans le temps."
    - "J'ai deja resolu un conflit de merge a la main, sans GUI ni tutoriel."
 
  virtualisation:
    - "Je peux creer, demarrer, et me connecter en SSH a une VM Linux en 15 minutes."
 
  regle_decision:
    - "Moins de 7/10 : reprendre la pre-preparation avant formation principale."
    - "7-9/10 : pret pour formation avec 1-2 semaines de consolidation ciblee."
    - "10/10 : pret sans reserve pour bootcamp intensif ou autodidaxie structuree."