Template Generator

Vue d'ensemble

La page Template Generator est un outil de génération automatique de templates de rapports de sécurité. Elle permet de créer des rapports professionnels à partir des données d'audit, avec support de différents formats (Markdown, HTML, PDF) et personnalisation avancée des sections et du contenu.

Fonctionnalités principales

1. Génération de templates automatique

• Parsing intelligent des données d'audit

• Génération de sections structurées

• Support multi-format (Markdown, HTML, PDF)

• Templates personnalisables par type d'audit

2. Parsing des données Nmap

• Analyse des scans de ports et services

• Détection des vulnérabilités

• Classification des risques

• Génération de recommandations

3. Personnalisation avancée

• Métadonnées du rapport (titre, date, auditeur)

• Sections personnalisables

• Styles et formatage

• Logos et branding

4. Interface utilisateur

• Éditeur de template en temps réel

• Prévisualisation du rendu final

• Export vers différents formats

• Sauvegarde des templates

Interface utilisateur

Header principal

• Logo et titre de l'application

• Boutons d'action (générer, exporter, sauvegarder)

• Sélecteur de format de sortie

• Options de personnalisation

Zone de configuration

• Métadonnées du rapport

• Paramètres de génération

• Options de formatage

• Sélection des sections

Zone d'édition

• Éditeur de template avec syntaxe highlightée

• Prévisualisation en temps réel

• Navigation entre les sections

• Validation de la syntaxe

Zone de sortie

• Rendu final du template

• Boutons d'export par format

• Options de téléchargement

• Partage des résultats

Composants techniques

TemplateGeneratorPage.tsx

Fichier principal : src/components/features/template-generator/TemplateGeneratorPage.tsx

Fonctionnalités clés :

• Parsing des données Nmap

• Génération de templates

• Édition et prévisualisation

• Export multi-format

Types de données :

interface ParsedService {
  port: number;
  proto: string;
  service: string;
  version?: string;
  state?: string;
}

interface ReportMetadata {
  title: string;
  date: string;
  auditor: string;
  client: string;
  scope: string;
  classification: string;
}

interface TemplateSection {
  id: string;
  title: string;
  content: string;
  order: number;
  enabled: boolean;
}

Parser Nmap

function parseNmapSimple(nmapText: string): ParsedService[] {
  const lines = nmapText.split(/\r?\n/);
  const services: ParsedService[] = [];
  
  // Regex stricte pour capturer les lignes de service nmap
  const serviceRegex = /^(\d{1,5})\/(tcp|udp)\s+(open|closed|filtered|open\|filtered)\s+([a-zA-Z][a-zA-Z0-9\-_\/]*\??)\s*(.*)$/i;
  
  for (const line of lines) {
    const trimmedLine = line.trim();
    
    // Ignorer les lignes vides et métadonnées
    if (!trimmedLine || 
        trimmedLine.startsWith('|') || 
        trimmedLine.startsWith('|_') || 
        trimmedLine.includes('PORT') ||
        trimmedLine.includes('STATE') ||
        trimmedLine.includes('SERVICE')) {
      continue;
    }
    
    const match = trimmedLine.match(serviceRegex);
    if (match) {
      const [, port, proto, state, service, version] = match;
      services.push({
        port: parseInt(port),
        proto: proto.toLowerCase(),
        service: service.toLowerCase(),
        version: version?.trim() || undefined,
        state: state.toLowerCase()
      });
    }
  }
  
  return services;
}

Modèle de données

Structure du template

interface ReportTemplate {
  metadata: ReportMetadata;
  sections: TemplateSection[];
  services: ParsedService[];
  vulnerabilities: Vulnerability[];
  recommendations: Recommendation[];
  style: TemplateStyle;
}

interface TemplateStyle {
  theme: 'light' | 'dark' | 'corporate';
  colors: {
    primary: string;
    secondary: string;
    accent: string;
  };
  fonts: {
    heading: string;
    body: string;
    code: string;
  };
  layout: {
    columns: number;
    spacing: string;
    margins: string;
  };
}

Sections de rapport

interface ReportSections {
  executive: {
    summary: string;
    findings: string;
    recommendations: string;
  };
  methodology: {
    scope: string;
    approach: string;
    tools: string;
  };
  findings: {
    services: ServiceSection[];
    vulnerabilities: VulnerabilitySection[];
    recommendations: RecommendationSection[];
  };
  technical: {
    details: string;
    evidence: string;
    remediation: string;
  };
  appendices: {
    tools: string;
    references: string;
    glossary: string;
  };
}

Workflow d'utilisation

1. Configuration des métadonnées

1. Saisir les informations du rapport

2. Définir le périmètre d'audit

3. Configurer les paramètres de génération

4. Choisir le style et le format

2. Import des données

1. Coller les résultats de scan Nmap

2. Parser automatiquement les services

3. Valider les données importées

4. Ajuster les classifications si nécessaire

3. Génération du template

1. Sélectionner les sections à inclure

2. Personnaliser le contenu des sections

3. Générer le template automatiquement

4. Vérifier la cohérence du rapport

4. Édition et finalisation

1. Éditer le template généré

2. Ajuster le formatage et le style

3. Ajouter des éléments personnalisés

4. Valider la syntaxe et la structure

5. Export et partage

1. Choisir le format de sortie

2. Exporter le rapport final

3. Partager avec les parties prenantes

4. Sauvegarder le template pour réutilisation

Fonctionnalités avancées

Parsing intelligent

• Détection automatique du format des données

• Validation de la structure des scans

• Correction des erreurs de format

• Support de multiples versions d'outils

Génération de contenu

• Templates prédéfinis par type d'audit

• Génération automatique des recommandations

• Classification des risques

• Personnalisation du contenu

Export multi-format

• Markdown : Format texte avec syntaxe

• HTML : Format web avec styles

• PDF : Format imprimable

• Word : Format document professionnel

Personnalisation

Création de templates personnalisés

1. Définir la structure des sections

2. Créer les templates de contenu

3. Configurer les styles et formatage

4. Tester avec des données réelles

Modification des sections

1. Éditer le contenu des sections existantes

2. Ajouter de nouvelles sections

3. Réorganiser l'ordre des sections

4. Personnaliser le formatage

Styles et thèmes

1. Choisir parmi les thèmes prédéfinis

2. Personnaliser les couleurs et polices

3. Adapter la mise en page

4. Créer des thèmes personnalisés

Intégration technique

Stack technologique

• React : Interface utilisateur

• TypeScript : Typage strict

• ReactMarkdown : Rendu Markdown

• html2pdf : Génération PDF

Gestion d'état

interface TemplateState {
  metadata: ReportMetadata;
  services: ParsedService[];
  template: string;
  preview: string;
  format: 'markdown' | 'html' | 'pdf';
  style: TemplateStyle;
  sections: TemplateSection[];
}

Fonctions utilitaires

function downloadText(filename: string, content: string) {
  const blob = new Blob([content], { type: 'text/plain' });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = filename;
  document.body.appendChild(a);
  a.click();
  document.body.removeChild(a);
  URL.revokeObjectURL(url);
}

function generatePDF(htmlContent: string) {
  const element = document.createElement('div');
  element.innerHTML = htmlContent;
  html2pdf().from(element).save('rapport-audit.pdf');
}

Utilisation recommandée

Pour les pentesteurs

1. Génération rapide de rapports

2. Standardisation du format

3. Personnalisation selon les besoins

4. Réutilisation des templates

Pour les équipes

1. Cohérence des rapports d'équipe

2. Partage des templates

3. Formation sur la génération

4. Amélioration continue des templates

Pour les managers

1. Qualité des livrables

2. Efficacité de la génération

3. Personnalisation client

4. Professionnalisme des rapports

Maintenance et évolution

Mise à jour des templates

1. Ajout de nouvelles sections

2. Amélioration du parsing

3. Support de nouveaux formats

4. Correction des bugs

Améliorations possibles

1. Intégration avec d'autres outils

2. Templates basés sur l'IA

3. Collaboration en temps réel

4. API pour l'intégration externe

Dépannage

Problèmes courants

1. Parsing échoue : Vérifier le format des données

2. Template invalide : Contrôler la syntaxe

3. Export échoue : Vérifier les permissions

4. Rendu incorrect : Valider le HTML/Markdown

Logs et débogage

1. Console du navigateur pour les erreurs JavaScript

2. Validation des données pour les erreurs de parsing

3. Test des templates avec des exemples

4. Vérification des formats d'export

Bonnes pratiques

Génération de rapports

1. Valider les données avant génération

2. Personnaliser selon le contexte

3. Vérifier la cohérence du contenu

4. Tester les différents formats

Gestion des templates

1. Sauvegarder les templates importants

2. Versionner les modifications

3. Partager avec l'équipe

4. Documenter les personnalisations

---

Cette documentation couvre l'utilisation complète de la page Template Generator pour la génération automatique de rapports de sécurité professionnels.