♻️ refactor (api): Flask to FastAPI

.env.example

@@ -0,0 +1,3 @@
+OPENROUTER_API_KEY=votre_clé_api_ici
+API_URL=https://openrouter.ai/api/v1/chat/completions
+MODEL=deepseek/deepseek-chat:free

.gitignore

@@ -0,0 +1,9 @@
+.env
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+*.log

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -9,4 +9,166 @@ license: mit
 short_description: 'AfricTivistes Digital Security Audit '
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# API d'Analyse d'Audit de Sécurité
+
+API Flask permettant d'analyser automatiquement les réponses à un audit de sécurité et de générer des recommandations via l'intelligence artificielle.
+
+## Présentation
+
+Cette API utilise l'intelligence artificielle pour analyser les réponses fournies lors d'un audit de sécurité informatique. Elle identifie automatiquement le type d'audit, évalue le niveau de sécurité global, détecte les points forts et les vulnérabilités, puis génère des recommandations personnalisées.
+
+## Fonctionnalités
+
+- **Détection automatique du type d'audit** (complet ou spécifique à un domaine)
+- **Analyse des réponses** par IA spécialisée en cybersécurité
+- **Évaluation du niveau de sécurité** avec score sur 10
+- **Identification des points forts** et leur importance
+- **Détection des vulnérabilités** et classification par niveau de risque
+- **Génération de recommandations détaillées** pour remédier aux failles
+- **Production d'un résumé** de la situation et des étapes prioritaires
+
+## Prérequis
+
+- Python 3.7+
+- Bibliothèques: Flask, Requests
+- Clé API OpenRouter (ou autre fournisseur de modèles LLM)
+
+## Installation
+
+1. Clonez le dépôt:
+```bash
+git clone https://github.com/AfricTivistes/adisa.git
+cd adisa
+```
+
+2. Installez les dépendances:
+```bash
+pip install -r requirements.txt
+```
+
+3. Configurez votre clé API dans `app.py` ou via une variable d'environnement.
+
+## Utilisation
+
+### Démarrer l'API
+
+```bash
+uvicorn app:app --host 0.0.0.0 --port 7860
+```
+
+L'API sera accessible par défaut sur `http://localhost:7860`.
+
+### Endpoints
+
+#### 1. Analyse d'audit
+
+**Endpoint**: `POST /api/analyze`
+
+**Description**: Analyse les réponses d'un audit de sécurité et génère une évaluation complète.
+
+**Format de requête**:
+```json
+{
+  "Question 1": "Réponse 1",
+  "Question 2": "Réponse 2",
+  "Comment gérez-vous les mots de passe?": "Nous utilisons un gestionnaire de mots de passe d'entreprise",
+  ...
+}
+```
+
+**Format de réponse**:
+```json
+{
+  "status": "success",
+  "audit_type": "Audit spécifique: Politique de mots de passe",
+  "evaluation": {
+    "score": 7,
+    "level": "Bon"
+  },
+  "strengths": [
+    {
+      "text": "Utilisation d'un gestionnaire de mots de passe centralisé",
+      "rating": "Fort"
+    },
+    ...
+  ],
+  "weaknesses": [
+    {
+      "text": "Absence de politique de changement régulier des mots de passe",
+      "rating": "Moyen"
+    },
+    ...
+  ],
+  "recommendations": [
+    "Mettre en place une authentification à deux facteurs pour tous les services critiques",
+    "Automatiser la détection des mots de passe faibles",
+    ...
+  ],
+  "summary": "La gestion des mots de passe présente un bon niveau général mais nécessite des améliorations..."
+}
+```
+
+#### 2. Vérification de santé
+
+**Endpoint**: `GET /api/health`
+
+**Description**: Vérifie que l'API est opérationnelle.
+
+**Format de réponse**:
+```json
+{
+  "status": "ok",
+  "message": "API d'analyse d'audit de sécurité opérationnelle"
+}
+```
+
+## Personnalisation
+
+### Modification du modèle d'IA
+
+Vous pouvez modifier le modèle utilisé en changeant les paramètres dans le constructeur de la classe `SecurityAuditAnalyzer`:
+
+```python
+security_analyzer = SecurityAuditAnalyzer(
+    api_key="votre-clé-api",
+    model="autre-modèle"
+)
+```
+
+### Types d'audits supportés
+
+L'API détecte automatiquement plusieurs domaines de la cybersécurité:
+
+- Politique de mots de passe
+- Sécurité des réseaux
+- Gestion des accès
+- Protection des données
+- Sécurité physique
+- Formation et sensibilisation
+- Gestion des incidents
+- Conformité réglementaire
+
+## Architecture du code
+
+- `app.py` : Point d'entrée de l'application Flask et définition des routes
+- `SecurityAuditAnalyzer` : Classe principale pour l'analyse des audits
+  - `analyze_responses()` : Méthode principale d'analyse
+  - `_build_prompt()` : Construction du prompt pour l'IA
+  - `_detect_audit_type()` : Détection automatique du type d'audit
+  - `_parse_analysis()` : Extraction des données structurées
+
+## Sécurité
+
+⚠️ **Attention**: Ne stockez jamais votre clé API directement dans le code en production. Utilisez plutôt des variables d'environnement ou un fichier de configuration sécurisé.
+
+## Exemple d'utilisation avec cURL
+
+```bash
+curl -X POST http://localhost:7860/api/analyze \
+  -H "Content-Type: application/json" \
+  -d '{
+    "Avez-vous une politique de mots de passe?": "Oui, nous exigeons des mots de passe d'au moins 8 caractères",
+    "Utilisez-vous l'authentification à deux facteurs?": "Seulement pour les comptes administrateurs",
+    "À quelle fréquence les mots de passe sont-ils changés?": "Il n'y a pas d'obligation de changement"
+  }'
+```

analyzer.py

@@ -0,0 +1,189 @@
+import requests
+import re
+
+class SecurityAuditAnalyzer:
+    def __init__(self, api_key, model="deepseek/deepseek-chat:free", api_url="https://openrouter.ai/api/v1/chat/completions"):
+        self.api_url = api_url
+        self.api_key = api_key
+        self.model = model
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+            "HTTP-Referer": "https://security-audit-api.com",
+            "X-Title": "Security Audit API"
+        }
+
+    def analyze_responses(self, responses):
+        """Analyse les réponses d'un audit et retourne une évaluation structurée."""
+        prompt = self._build_prompt(responses)
+        payload = {
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": self._get_system_prompt()},
+                {"role": "user", "content": prompt}
+            ],
+            "temperature": 0.5
+        }
+        try:
+            response = requests.post(self.api_url, headers=self.headers, json=payload)
+            response.raise_for_status()
+            result = response.json()
+            analysis = result['choices'][0]['message']['content']
+            return self._parse_analysis(analysis)
+        except requests.RequestException as e:
+            return {
+                "error": str(e),
+                "status": "error",
+                "evaluation": {"score": 0, "level": "Inconnu"},
+                "strengths": [], "weaknesses": [], "recommendations": [],
+                "summary": "Une erreur s'est produite lors de l'analyse."
+            }
+
+    def _get_system_prompt(self):
+        return """Vous êtes un expert en cybersécurité spécialisé dans l'analyse des audits de sécurité.
+Votre tâche est d'analyser les réponses fournies à un audit de sécurité et de produire une évaluation détaillée.
+
+Adaptez votre analyse au type d'audit fourni (audit complet ou audit spécifique à un domaine).
+Identifiez automatiquement le domaine spécifique de l'audit si les questions sont concentrées sur un sujet particulier 
+(ex: sécurité des réseaux, politique de mots de passe, gestion des données, etc.).
+
+Structurez toujours votre réponse avec les balises suivantes:
+<AUDIT_TYPE>Type de l'audit identifié</AUDIT_TYPE>
+<EVALUATION>Score sur 10 et niveau (Critique, Faible, Moyen, Bon, Excellent)</EVALUATION>
+<POINTS_FORTS>Liste des points forts avec leur niveau d'importance (Fort, Moyen, Faible)</POINTS_FORTS>
+<FAILLES>Liste des vulnérabilités identifiées avec leur niveau de risque (Critique, Élevé, Moyen, Faible)</FAILLES>
+<RECOMMANDATIONS>Liste des recommandations détaillées pour chaque faille identifiée</RECOMMANDATIONS>
+<RESUME>Résumé concis de la situation générale de sécurité et prochaines étapes prioritaires</RESUME>
+"""
+
+    def _build_prompt(self, responses):
+        audit_type = self._detect_audit_type(responses)
+        prompt = f"Type d'audit détecté: {audit_type}\n\n"
+        prompt += "Voici les réponses à un audit de sécurité numérique:\n\n"
+        for question, answer in responses.items():
+            prompt += f"Question: {question}\nRéponse: {answer}\n\n"
+        prompt += """
+Analysez ces réponses et fournissez:
+1. Le type d'audit que vous avez identifié
+2. Une évaluation globale du niveau de sécurité (score sur 10 et niveau: Critique, Faible, Moyen, Bon, Excellent)
+3. Les points forts de la sécurité actuelle (listez-les avec leur importance: Fort, Moyen, Faible)
+4. Les vulnérabilités identifiées (listez-les avec leur niveau de risque: Critique, Élevé, Moyen, Faible)
+5. Des recommandations détaillées pour résoudre chaque vulnérabilité
+6. Un résumé général de la situation actuelle et prochaines étapes prioritaires
+
+Formatez votre réponse avec les sections clairement délimitées par les balises spécifiées.
+"""
+        return prompt
+
+    def _detect_audit_type(self, responses):
+        domains = {
+            "Politique de mots de passe": ["mot de passe", "password", "authentification", "connexion"],
+            "Sécurité des réseaux": ["réseau", "network", "firewall", "pare-feu", "vpn", "wifi", "routeur"],
+            "Gestion des accès": ["accès", "access", "droits", "permission", "privilege", "utilisateur", "user"],
+            "Protection des données": ["donnée", "data", "chiffrement", "encryption", "backup", "sauvegarde"],
+            "Sécurité physique": ["physique", "physical", "bâtiment", "building", "local", "vol", "theft"],
+            "Formation et sensibilisation": ["formation", "training", "sensibilisation", "awareness", "employé"],
+            "Gestion des incidents": ["incident", "crise", "réponse", "response", "attaque", "breach"],
+            "Conformité réglementaire": ["rgpd", "gdpr", "conformité", "compliance", "régulation", "legal"]
+        }
+        domain_counts = {domain: 0 for domain in domains}
+        for question in responses.keys():
+            question_lower = question.lower()
+            for domain, keywords in domains.items():
+                for keyword in keywords:
+                    if keyword.lower() in question_lower:
+                        domain_counts[domain] += 1
+        main_domains = sorted(domain_counts.items(), key=lambda x: x[1], reverse=True)
+        if len(main_domains) > 3 and main_domains[0][1] > 0 and main_domains[1][1] > 0 and main_domains[2][1] > 0:
+            return "Audit de sécurité complet"
+        elif main_domains[0][1] > 0:
+            return f"Audit spécifique: {main_domains[0][0]}"
+        else:
+            return "Audit de sécurité général"
+
+    def _parse_analysis(self, analysis):
+        result = {
+            "status": "success",
+            "audit_type": self._extract_between(analysis, "<AUDIT_TYPE>", "</AUDIT_TYPE>"),
+            "evaluation": {},
+            "strengths": [],
+            "weaknesses": [],
+            "recommendations": [],
+            "summary": self._extract_between(analysis, "<RESUME>", "</RESUME>").strip()
+        }
+        eval_text = self._extract_between(analysis, "<EVALUATION>", "</EVALUATION>")
+        score_match = re.search(r'(\d+)[\/\s]*10', eval_text)
+        result["evaluation"]["score"] = int(score_match.group(1)) if score_match else 0
+
+        level_keywords = ["Critique", "Faible", "Moyen", "Bon", "Excellent"]
+        for keyword in level_keywords:
+            if keyword.lower() in eval_text.lower():
+                result["evaluation"]["level"] = keyword
+                break
+        else:
+            result["evaluation"]["level"] = "Non spécifié"
+
+        strengths_text = self._extract_between(analysis, "<POINTS_FORTS>", "</POINTS_FORTS>")
+        result["strengths"] = self._extract_rated_items(strengths_text, ["Fort", "Moyen", "Faible"])
+
+        weaknesses_text = self._extract_between(analysis, "<FAILLES>", "</FAILLES>")
+        result["weaknesses"] = self._extract_rated_items(weaknesses_text, ["Critique", "Élevé", "Moyen", "Faible"])
+
+        recommendations_text = self._extract_between(analysis, "<RECOMMANDATIONS>", "</RECOMMANDATIONS>")
+        result["recommendations"] = self._extract_list_items(recommendations_text)
+
+        if not result["audit_type"]:
+            if "audit complet" in analysis.lower():
+                result["audit_type"] = "Audit de sécurité complet"
+            elif "audit spécifique" in analysis.lower():
+                specific_match = re.search(r'audit spécifique[:\s]*([\w\s]+)', analysis.lower())
+                if specific_match:
+                    result["audit_type"] = f"Audit spécifique: {specific_match.group(1).strip().capitalize()}"
+                else:
+                    result["audit_type"] = "Audit spécifique"
+            else:
+                result["audit_type"] = "Audit de sécurité général"
+
+        return result
+
+    def _extract_between(self, text, start_marker, end_marker):
+        try:
+            start = text.index(start_marker) + len(start_marker)
+            end = text.index(end_marker, start)
+            return text[start:end].strip()
+        except ValueError:
+            return ""
+
+    def _extract_list_items(self, text):
+        items = []
+        for line in text.split('\n'):
+            line = line.strip()
+            if line.startswith(('- ', '• ', '* ', '1. ', '2. ')) and len(line) > 2:
+                items.append(line[2:].strip())
+            elif line and not any(header in line.lower() for header in ["points", "failles", "recommandations"]):
+                items.append(line)
+        return [item for item in items if item]
+
+    def _extract_rated_items(self, text, ratings):
+        items = []
+        for line in text.split('\n'):
+            line = line.strip()
+            if not line:
+                continue
+            item = {"text": line, "rating": None}
+            for rating in ratings:
+                if f"{rating}:" in line.lower() or f"{rating} :" in line.lower():
+                    parts = re.split(f"{rating}:", line, 1, flags=re.IGNORECASE)
+                    if len(parts) > 1:
+                        item["text"] = parts[1].strip()
+                        item["rating"] = rating
+                        break
+                if f"({rating})" in line.lower() or f"[{rating}]" in line.lower():
+                    item["text"] = re.sub(rf"[\(\[]?{rating}[\)\]]?", "", line, flags=re.IGNORECASE).strip()
+                    item["rating"] = rating
+                    break
+            if item["rating"] is None and line.startswith(('- ', '• ', '* ')) and len(line) > 2:
+                item["text"] = line[2:].strip()
+            if item["text"] and not any(header in item["text"].lower() for header in ["points forts", "failles"]):
+                items.append(item)
+        return items

app.py

@@ -0,0 +1,34 @@
+from fastapi import FastAPI, HTTPException
+from models import AuditResponses
+from analyzer import SecurityAuditAnalyzer
+from config import settings
+
+app = FastAPI(title="Security Audit API", description="API pour analyser les réponses d'audits de sécurité")
+
+# Initialisation de l'analyseur avec les paramètres de configuration
+security_analyzer = SecurityAuditAnalyzer(
+    api_key=settings.OPENROUTER_API_KEY,
+    model=settings.MODEL,
+    api_url=settings.API_URL
+)
+
+@app.post("/api/analyze")
+async def analyze_audit(responses: AuditResponses):
+    """
+    Analyse les réponses d'un audit de sécurité.
+    
+    Args:
+        responses: Dictionnaire de questions/réponses
+    
+    Returns:
+        Résultats structurés de l'analyse
+    """
+    analysis_result = security_analyzer.analyze_responses(responses.responses)
+    if analysis_result.get("status") == "error":
+        raise HTTPException(status_code=500, detail=analysis_result["error"])
+    return analysis_result
+
+@app.get("/api/health")
+async def health_check():
+    """Vérifie l'état de l'API."""
+    return {"status": "ok", "message": "API d'analyse d'audit de sécurité opérationnelle"}

config.py

@@ -0,0 +1,12 @@
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    OPENROUTER_API_KEY: str
+    API_URL: str = "https://openrouter.ai/api/v1/chat/completions"
+    MODEL: str = "deepseek/deepseek-chat:free"
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+
+settings = Settings()

models.py

@@ -0,0 +1,4 @@
+from pydantic import BaseModel
+
+class AuditResponses(BaseModel):
+    responses: dict[str, str]

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.111.0
+uvicorn==0.30.1
+requests==2.32.3
+pydantic==2.8.2
+pydantic-settings==2.3.4
+python-dotenv==1.0.1