Transfert de fichiers

Vue d'ensemble

La page File Transfer est un outil de génération de commandes pour le transfert de fichiers pendant les audits de sécurité. Elle propose des commandes optimisées pour différents scénarios de transfert (upload/download) entre différents systèmes d'exploitation, avec support des méthodes HTTP, SCP, Netcat, Base64, FTP et SMB.

Fonctionnalités principales

1. Génération de commandes multi-plateforme

• Support Linux, Windows, macOS pour source et destination

• Commandes adaptées selon l'OS cible

• Validation des paramètres de connexion

• Optimisation des commandes selon le contexte

2. Méthodes de transfert multiples

• HTTP/HTTPS : Serveurs web temporaires

• SCP/SFTP : Transfert sécurisé via SSH

• Netcat : Transfert direct via TCP/UDP

• Base64 : Encodage pour transfert par texte

• FTP : Transfert via protocole FTP

• SMB : Partage de fichiers Windows

3. Scénarios configurables

• Upload : Source vers destination

• Download : Destination vers source

• Double pivot : Transfert via machines intermédiaires

• Paramètres personnalisables (IP, ports, chemins)

4. Interface utilisateur

• Configuration interactive du scénario

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

• Copie vers le presse-papiers

• Historique des commandes utilisées

Interface utilisateur

Header principal

• Logo et titre de l'application

• Description de la fonctionnalité

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

Zone de configuration

• Paramètres du scénario (source, destination, direction)

• Sélection des OS pour chaque machine

• Configuration des IP et ports

• Validation des paramètres

Zone de génération

• Méthodes de transfert disponibles

• Commandes générées par méthode

• Boutons de copie individuels

• Expansion/réduction des sections

Composants techniques

FileTransferPage.tsx

Fichier principal : src/components/features/file-transfer/FileTransferPage.tsx

Fonctionnalités clés :

• Gestion des scénarios de transfert

• Génération des commandes par méthode

• Validation des paramètres

• Gestion de l'historique

Types de données :

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

interface ScenarioState {
  source: {
    os: OSEnum;
    ip: string;
    port: string;
    sshPort?: string;
  };
  destination: {
    os: OSEnum;
    ip: string;
    sshPort: string;
    port?: string;
    filename: string;
    destPath: string;
  };
  direction: 'upload' | 'download';
}

interface HistoryItem {
  id: string;
  method: string;
  step: string;
  command: string;
  context: any;
  createdAt: string;
}

Générateurs de commandes

Méthode HTTP

// Serveur HTTP Python
const httpServerCmd = `python3 -m http.server ${source.port}`;

// Téléchargement wget/curl
const httpDownloadCmd = `wget http://${source.ip}:${source.port}/${filename}`;

Méthode SCP/SFTP

// Upload via SCP
const scpUploadCmd = `scp ${filename} ${destUser}@${destIp}:${destPath}`;

// Download via SCP
const scpDownloadCmd = `scp ${destUser}@${destIp}:${destPath}/${filename} .`;

Méthode Netcat

// Serveur Netcat
const ncServerCmd = `nc -lvp ${source.port} < ${filename}`;

// Client Netcat
const ncClientCmd = `nc ${source.ip} ${source.port} > ${filename}`;

Modèle de données

Configuration du scénario

interface TransferScenario {
  source: {
    os: OSEnum;           // OS de la machine source
    ip: string;           // IP de la machine source
    port: string;         // Port d'écoute (HTTP/NC/FTP)
    sshPort?: string;     // Port SSH pour SCP/SFTP
  };
  destination: {
    os: OSEnum;           // OS de la machine destination
    ip: string;           // IP de la machine destination
    sshPort: string;      // Port SSH pour SCP/SFTP
    port?: string;        // Port HTTP si destination = source
    filename: string;     // Nom du fichier à transférer
    destPath: string;     // Chemin de destination
  };
  direction: 'upload' | 'download';
}

Historique des commandes

interface CommandHistory {
  id: string;             // Identifiant unique
  method: string;         // Méthode utilisée (HTTP, SCP, etc.)
  step: string;           // Étape du transfert
  command: string;        // Commande générée
  context: any;           // Contexte du scénario
  createdAt: string;      // Date de création
}

Workflow d'utilisation

1. Configuration du scénario

1. Sélectionner l'OS source et destination

2. Saisir les adresses IP et ports

3. Définir le nom du fichier et le chemin de destination

4. Choisir la direction du transfert (upload/download)

2. Génération des commandes

1. Sélectionner les méthodes de transfert souhaitées

2. Générer les commandes pour chaque méthode

3. Vérifier la validité des commandes

4. Ajuster les paramètres si nécessaire

3. Exécution du transfert

1. Copier les commandes vers le presse-papiers

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

3. Vérifier le succès du transfert

4. Sauvegarder les commandes dans l'historique

4. Gestion de l'historique

1. Consulter l'historique des commandes

2. Réutiliser des scénarios précédents

3. Partager les commandes avec l'équipe

4. Documenter les transferts effectués

Fonctionnalités avancées

Génération intelligente

• Détection automatique de la meilleure méthode

• Adaptation des commandes selon l'OS

• Optimisation des paramètres de transfert

• Validation des chemins et permissions

Support multi-plateforme

• Commandes Windows (PowerShell, CMD)

• Commandes Linux (bash, zsh)

• Commandes macOS (bash, zsh)

• Adaptation des chemins selon l'OS

Gestion de l'historique

• Sauvegarde automatique des commandes

• Recherche dans l'historique

• Filtrage par méthode ou date

• Export de l'historique

Personnalisation

Ajout de nouvelles méthodes

1. Définir la méthode dans l'interface

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

3. Ajouter la validation des paramètres

4. Tester la nouvelle méthode

Modification des templates

1. Éditer les templates de commandes

2. Ajouter de nouveaux paramètres

3. Personnaliser la validation

4. Optimiser les performances

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

• localStorage : Persistance de l'historique

Fonctions utilitaires

function buildDestFullPath(destPath: string, filename: string, os: OSEnum): string {
  const isWindows = os === 'windows';
  const sep = isWindows ? '\\' : '/';
  if (!destPath) return isWindows ? `C:\\temp\\${filename}` : `/tmp/${filename}`;
  const endsWithSep = isWindows ? /\\$/.test(destPath) : /\/$/.test(destPath);
  return endsWithSep ? `${destPath}${filename}` : `${destPath}${sep}${filename}`;
}

function copyToClipboard(cmd: string) {
  navigator.clipboard.writeText(cmd).then(() => {
    toast.success('Commande copiée');
  }).catch(() => toast.error('Copie impossible'));
}

Gestion de l'historique

const [history, setHistory] = useState<HistoryItem[]>(() => {
  try {
    const raw = localStorage.getItem(STORAGE_KEY_HISTORY);
    return raw ? JSON.parse(raw) : [];
  } catch {
    return [];
  }
});

Utilisation recommandée

Pour les pentesteurs

1. Transfert rapide de fichiers d'exploitation

2. Adaptation aux différents environnements

3. Documentation des méthodes utilisées

4. Optimisation des transferts

Pour les équipes

1. Standardisation des méthodes de transfert

2. Partage des commandes utiles

3. Formation sur les techniques

4. Collaboration sur les transferts

Pour les formateurs

1. Démonstration des techniques de transfert

2. Exercices pratiques

3. Templates pour les étudiants

4. Documentation des bonnes pratiques

Maintenance et évolution

Mise à jour des méthodes

1. Ajout de nouvelles méthodes de transfert

2. Amélioration des commandes existantes

3. Support de nouveaux protocoles

4. Optimisation des performances

Améliorations possibles

1. Intégration avec des outils de transfert

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. Transfert échoue : Contrôler la connectivité réseau

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

4. Fichiers corrompus : Vérifier l'intégrité des transferts

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 transfert

Bonnes pratiques

Configuration des transferts

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

2. Tester les commandes sur des environnements de test

3. Documenter les méthodes utilisées

4. Sauvegarder les commandes importantes

Sécurité des transferts

1. Utiliser des méthodes sécurisées (SCP, HTTPS)

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

3. Chiffrer les transferts sensibles

4. Nettoyer les fichiers temporaires

---

Cette documentation couvre l'utilisation complète de la page File Transfer pour la génération de commandes de transfert de fichiers pendant les audits de sécurité.