Aide aux pivots

Vue d'ensemble

La page Pivot Master est un outil de génération de commandes pour les techniques de pivot réseau pendant les audits de sécurité. Elle propose des commandes optimisées pour différents scénarios de pivot (simple, double) avec support de SSH, Ligolo, Chisel, SSHuttle et autres méthodes, adaptées aux différents systèmes d'exploitation.

Fonctionnalités principales

1. Génération de commandes de pivot

• Support multi-plateforme (Linux, Windows, macOS)

• Scénarios configurables (simple pivot, double pivot)

• Méthodes multiples : SSH, Ligolo, Chisel, SSHuttle, Socat

• Recommandations automatiques selon le contexte

2. Stratégies de pivot avancées

• SSH ProxyJump : Pivot via SSH avec sauts multiples

• Ligolo : Tunneling IP avec agents légers

• Chisel : Tunneling TCP/UDP avec chiffrement

• SSHuttle : Routage IP via SSH

• Socat : Redirection de ports simple

3. Configuration intelligente

• Détection automatique de la meilleure stratégie

• Validation des paramètres de connexion

• Optimisation des commandes selon l'environnement

• Support des environnements complexes

4. Interface utilisateur

• Configuration interactive du scénario

• Prévisualisation des commandes générées

• Copie vers le presse-papiers

• Conseils et bonnes pratiques

Interface utilisateur

Header principal

• Logo et titre de l'application

• Description de la fonctionnalité

• Boutons d'action (générer, copier, conseils)

Zone de configuration

• Paramètres du scénario (attaquant, pivots, cible)

• Sélection des OS pour chaque machine

• Configuration des IP et ports

• Stratégie de pivot (auto, SSH, Ligolo, etc.)

Zone de génération

• Commandes générées par stratégie

• Étapes détaillées du pivot

• Boutons de copie individuels

• Conseils d'implémentation

Composants techniques

PivotMasterPage.tsx

Fichier principal : src/components/features/pivot/PivotMasterPage.tsx

Fonctionnalités clés :

• Gestion des scénarios de pivot

• Génération des commandes par stratégie

• Recommandations automatiques

• Validation des paramètres

Types de données :

type OSEnum = 'linux' | 'windows' | 'macos';

interface PivotNode {
  label: string;
  ip: string;
  os: OSEnum;
  hasSSH: boolean;
  canRunAgent: boolean;
  sshUser: string;
}

interface PivotScenario {
  attacker: { ip: string; socksPort: string };
  pivot1: PivotNode | null;
  pivot2: PivotNode | null;
  target: { ip: string; subnet: string };
  strategy: 'auto' | 'ssh' | 'ligolo' | 'chisel' | 'sshuttle' | 'socat';
}

Générateurs de commandes

Stratégie SSH

// Simple pivot SSH
const sshSimpleCmd = `ssh -D ${socksPort} -N ${pivot1.sshUser}@${pivot1.ip}`;

// Double pivot SSH
const sshDoubleCmd = `ssh -J ${pivot1.sshUser}@${pivot1.ip},${pivot2.sshUser}@${pivot2.ip} -D ${socksPort} -N ${pivot2.sshUser}@${pivot2.ip}`;

// Port forwarding
const sshPortForwardCmd = `ssh -J ${pivot1.sshUser}@${pivot1.ip} -L 0.0.0.0:9001:${target.ip}:22 -N ${pivot1.sshUser}@${pivot1.ip}`;

Stratégie Ligolo

// Serveur Ligolo (attaquant)
const ligoloServerCmd = `./ligolo-ng -selfcert -laddr 0.0.0.0:11601`;

// Agent Ligolo (pivot)
const ligoloAgentCmd = `./ligolo-ng -connect ${attacker.ip}:11601 -ignore-cert`;

Stratégie Chisel

// Serveur Chisel (attaquant)
const chiselServerCmd = `./chisel server --port 8080 --reverse`;

// Client Chisel (pivot)
const chiselClientCmd = `./chisel client ${attacker.ip}:8080 R:${socksPort}:socks`;

Modèle de données

Configuration du scénario

interface PivotConfiguration {
  attacker: {
    ip: string;           // IP de l'attaquant
    socksPort: string;    // Port SOCKS local
  };
  pivot1: {
    label: string;        // Nom du premier pivot
    ip: string;           // IP du premier pivot
    os: OSEnum;           // OS du premier pivot
    hasSSH: boolean;      // Support SSH
    canRunAgent: boolean; // Peut exécuter des agents
    sshUser: string;      // Utilisateur SSH
  };
  pivot2?: {
    label: string;        // Nom du second pivot
    ip: string;           // IP du second pivot
    os: OSEnum;           // OS du second pivot
    hasSSH: boolean;      // Support SSH
    canRunAgent: boolean; // Peut exécuter des agents
    sshUser: string;      // Utilisateur SSH
  };
  target: {
    ip: string;           // IP de la cible
    subnet: string;       // Sous-réseau cible
  };
  strategy: PivotStrategy;
}

Stratégies de pivot

type PivotStrategy = 'auto' | 'ssh' | 'ligolo' | 'chisel' | 'sshuttle' | 'socat';

interface StrategyRecommendation {
  strategy: PivotStrategy;
  reason: string;
  complexity: 'low' | 'medium' | 'high';
  requirements: string[];
}

Workflow d'utilisation

1. Configuration du scénario

1. Définir l'IP de l'attaquant et le port SOCKS

2. Configurer le premier pivot (OS, IP, capacités)

3. Ajouter un second pivot si nécessaire

4. Spécifier la cible et son sous-réseau

2. Sélection de la stratégie

1. Choisir la stratégie manuellement ou en mode auto

2. Consulter les recommandations automatiques

3. Vérifier les prérequis de chaque stratégie

4. Ajuster la configuration si nécessaire

3. Génération des commandes

1. Générer les commandes pour la stratégie choisie

2. Vérifier la cohérence des commandes

3. Adapter les paramètres selon l'environnement

4. Copier les commandes vers le presse-papiers

4. Implémentation du pivot

1. Exécuter les commandes sur les machines concernées

2. Vérifier la connectivité via le pivot

3. Tester l'accès aux services cibles

4. Documenter la configuration du pivot

Fonctionnalités avancées

Recommandations intelligentes

• Analyse des capacités des pivots

• Sélection de la meilleure stratégie

• Évaluation de la complexité

• Vérification des prérequis

Support multi-plateforme

• Commandes Windows (PowerShell, CMD)

• Commandes Linux (bash, zsh)

• Commandes macOS (bash, zsh)

• Adaptation des chemins selon l'OS

Gestion des erreurs

• Validation des paramètres de connexion

• Vérification de la cohérence du scénario

• Détection des configurations impossibles

• Suggestions de correction

Personnalisation

Ajout de nouvelles stratégies

1. Définir la stratégie dans l'interface

2. Implémenter la génération de commandes

3. Ajouter la validation des prérequis

4. Tester avec des scénarios réels

Modification des templates

1. Éditer les templates de commandes

2. Améliorer la détection des capacités

3. Optimiser les recommandations

4. Ajouter de nouveaux paramètres

Interface utilisateur

1. Réorganiser les sections

2. Ajouter de nouveaux contrôles

3. Personnaliser les validations

4. Améliorer l'expérience utilisateur

Intégration technique

Stack technologique

• React : Interface utilisateur

• TypeScript : Typage strict

• useState/useMemo : Gestion d'état

• Toast : Notifications utilisateur

Fonctions utilitaires

function copy(cmd: string) {
  navigator.clipboard.writeText(cmd).then(() => 
    toast.success('Commande copiée')
  );
}

function safeWin(p: string) { 
  return p.replace(/\\/g, '\\\\'); 
}

Logique de recommandation

const recommended = useMemo(() => {
  if (scenario.strategy !== 'auto') return scenario.strategy;
  
  const p1 = scenario.pivot1;
  const p2 = scenario.pivot2;
  
  if (isDoublePivot) {
    if (p1?.hasSSH && p2?.hasSSH) return 'ssh';
    if (p1?.canRunAgent && p2?.canRunAgent) return 'ligolo';
    return 'chisel';
  } else {
    if (p1?.hasSSH) return 'ssh';
    if (p1?.canRunAgent) return 'ligolo';
    return 'chisel';
  }
}, [scenario]);

Utilisation recommandée

Pour les pentesteurs

1. Configuration rapide des pivots

2. Adaptation aux différents environnements

3. Optimisation des techniques de pivot

4. Documentation des configurations

Pour les équipes

1. Standardisation des techniques de pivot

2. Partage des configurations efficaces

3. Formation sur les méthodes

4. Collaboration sur les pivots complexes

Pour les formateurs

1. Démonstration des techniques de pivot

2. Exercices pratiques

3. Templates pour les étudiants

4. Documentation des bonnes pratiques

Maintenance et évolution

Mise à jour des stratégies

1. Ajout de nouvelles méthodes de pivot

2. Amélioration des commandes existantes

3. Support de nouveaux outils

4. Optimisation des performances

Améliorations possibles

1. Intégration avec des outils de pivot

2. Validation en temps réel des paramètres

3. Templates basés sur l'environnement

4. API pour l'intégration externe

Dépannage

Problèmes courants

1. Commandes invalides : Vérifier les paramètres saisis

2. Pivot échoue : Contrôler la connectivité réseau

3. Permissions refusées : Vérifier les droits d'accès

4. Configuration incorrecte : Valider le scénario

Logs et débogage

1. Console du navigateur pour les erreurs JavaScript

2. Validation des paramètres pour les erreurs de format

3. Test des commandes sur les systèmes cibles

4. Vérification des logs de pivot

Bonnes pratiques

Configuration des pivots

1. Valider tous les paramètres avant génération

2. Tester les commandes sur des environnements de test

3. Documenter les configurations utilisées

4. Sauvegarder les commandes importantes

Sécurité des pivots

1. Utiliser des connexions chiffrées

2. Vérifier l'intégrité des tunnels

3. Nettoyer les configurations après usage

4. Surveiller l'activité des pivots

---

Cette documentation couvre l'utilisation complète de la page Pivot Master pour la génération de commandes de pivot réseau pendant les audits de sécurité.