mira_ia.py — v2 (chemins + mots de passe sécurisés)

[Mario Da Conceicao]

Version corrigée du 25/07/2026 — étape 2 du portage Linux. Deux changements :

1. Chemins calculés automatiquement (plus de « D:… » en dur)
2. ⚠️ Sécurité : les mots de passe sont maintenant hachés (SHA-256 + sel), alignés sur la méthode déjà utilisée dans interface_demarrage.py. Avant, ce fichier stockait et comparait les mots de passe en clair — c’est corrigé.

import json
import os
import shutil
import hashlib
import secrets
from pathlib import Path
from datetime import datetime

# --- CORRECTION 1 : chemin calculé automatiquement ---
BASE_DIR = Path(__file__).resolve().parent

# --- CORRECTION 2 : fonctions de hachage, identiques à interface_demarrage.py ---
def hacher_mot_de_passe(mot_de_passe: str) -> str:
    salt = secrets.token_hex(16)
    h = hashlib.sha256((mot_de_passe + salt).encode("utf-8")).hexdigest()
    return f"{salt}:{h}"

def verifier_mot_de_passe(mot_de_passe: str, stocke: str) -> bool:
    try:
        salt, h = stocke.split(":")
        return hashlib.sha256((mot_de_passe + salt).encode("utf-8")).hexdigest() == h
    except Exception:
        return False

class MiraIA:
    def __init__(self, version_actuelle="0.3"):
        self.version_actuelle = version_actuelle
        self.fichier_mises_a_jour = BASE_DIR / "mises_a_jour.json"
        self.fichier_ameliorations = BASE_DIR / "ameliorations.txt"
        self.fichier_propositions = BASE_DIR / "propositions_ia.json"
        self.fichier_logs = BASE_DIR / "logs.txt"
        self.fichier_utilisateurs = BASE_DIR / "utilisateurs.json"
        self.fichier_connaissances = BASE_DIR / "connaissances.json"

        if not self.fichier_ameliorations.exists():
            open(self.fichier_ameliorations, "w", encoding="utf-8").close()
        if not self.fichier_propositions.exists():
            with open(self.fichier_propositions, "w", encoding="utf-8") as f:
                json.dump([], f)
        if not self.fichier_logs.exists():
            open(self.fichier_logs, "w", encoding="utf-8").close()
        if not self.fichier_utilisateurs.exists():
            with open(self.fichier_utilisateurs, "w", encoding="utf-8") as f:
                json.dump({"utilisateurs": []}, f)
        if not self.fichier_connaissances.exists():
            with open(self.fichier_connaissances, "w", encoding="utf-8") as f:
                json.dump({}, f)

    def verifier_mises_a_jour(self):
        if self.fichier_mises_a_jour.exists():
            with open(self.fichier_mises_a_jour, "r", encoding="utf-8") as f:
                mises_a_jour = json.load(f)
                if mises_a_jour["version"] > self.version_actuelle:
                    return mises_a_jour
        return None

    def appliquer_mise_a_jour(self, mise_a_jour):
        print(f"Application de la mise à jour vers la version {mise_a_jour['version']}...")
        for fichier in mise_a_jour["fichiers"]:
            chemin_source = fichier["chemin_source"]
            chemin_destination = fichier["chemin_destination"]
            shutil.copy2(chemin_source, chemin_destination)
            print(f"Fichier {fichier['nom']} mis à jour.")
        print("Mise à jour terminée !")

    def proposer_amelioration(self, suggestion):
        with open(self.fichier_ameliorations, "a", encoding="utf-8") as f:
            f.write(f"{datetime.now()} - Suggestion: {suggestion}\n")
        print(f"Suggestion enregistrée : {suggestion}")
        self.analyser_suggestions()

    def analyser_suggestions(self):
        if not self.fichier_ameliorations.exists():
            return

        with open(self.fichier_ameliorations, "r", encoding="utf-8") as f:
            suggestions = f.readlines()

        propositions_existantes = []
        if self.fichier_propositions.exists():
            with open(self.fichier_propositions, "r", encoding="utf-8") as f:
                propositions_existantes = json.load(f)

        descriptions_existantes = [prop["description"] for prop in propositions_existantes]

        nouvelles_propositions = []
        for suggestion in suggestions:
            suggestion_nettoyee = suggestion.split("Suggestion: ")[-1].strip()

            proposition = None
            if "clavier" in suggestion_nettoyee.lower() or "virtuel" in suggestion_nettoyee.lower():
                proposition = {
                    "type": "nouvelle_fonctionnalite",
                    "description": "Ajouter un module de clavier virtuel pour faciliter la saisie.",
                    "fichiers_a_modifier": ["mira_os.py"],
                    "explication": "Un clavier virtuel pourrait aider les utilisateurs à entrer des commandes ou du texte plus facilement.",
                    "date": str(datetime.now())
                }
            elif "jeu" in suggestion_nettoyee.lower():
                proposition = {
                    "type": "nouvelle_fonctionnalite",
                    "description": "Ajouter un module 'Jeux' avec un jeu de devinette.",
                    "fichiers_a_modifier": ["mira_os.py"],
                    "explication": "Beaucoup d'utilisateurs demandent des jeux.",
                    "date": str(datetime.now())
                }
            elif "bug" in suggestion_nettoyee.lower() or "erreur" in suggestion_nettoyee.lower():
                proposition = {
                    "type": "correction",
                    "description": "Corriger les bugs dans la calculatrice.",
                    "fichiers_a_modifier": ["mira_os.py"],
                    "explication": "Des vérifications supplémentaires pourraient être ajoutées.",
                    "date": str(datetime.now())
                }
            elif "calculatrice" in suggestion_nettoyee.lower():
                proposition = {
                    "type": "amelioration",
                    "description": "Ajouter des fonctions avancées à la calculatrice (racine carrée, puissance).",
                    "fichiers_a_modifier": ["mira_os.py"],
                    "explication": "La calculatrice pourrait être améliorée avec des fonctions mathématiques avancées.",
                    "date": str(datetime.now())
                }

            if proposition and proposition["description"] not in descriptions_existantes:
                nouvelles_propositions.append(proposition)
                descriptions_existantes.append(proposition["description"])

        toutes_propositions = propositions_existantes + nouvelles_propositions
        with open(self.fichier_propositions, "w", encoding="utf-8") as f:
            json.dump(toutes_propositions, f, indent=4, ensure_ascii=False)

    def get_propositions(self):
        if self.fichier_propositions.exists():
            with open(self.fichier_propositions, "r", encoding="utf-8") as f:
                return json.load(f)
        return []

    def verifier_utilisateur(self, nom, mot_de_passe):
        # CORRECTION SÉCURITÉ : comparaison via hachage, plus jamais en clair
        if not self.fichier_utilisateurs.exists():
            return False
        with open(self.fichier_utilisateurs, "r", encoding="utf-8") as f:
            data = json.load(f)
        for utilisateur in data.get("utilisateurs", []):
            if utilisateur["nom"] == nom and verifier_mot_de_passe(mot_de_passe, utilisateur["mot_de_passe"]):
                return True
        return False

    def ajouter_utilisateur(self, nom, mot_de_passe, role="utilisateur"):
        # CORRECTION SÉCURITÉ : le mot de passe est haché avant d'être stocké
        if not self.fichier_utilisateurs.exists():
            data = {"utilisateurs": []}
        else:
            with open(self.fichier_utilisateurs, "r", encoding="utf-8") as f:
                data = json.load(f)
        data["utilisateurs"].append({
            "nom": nom,
            "mot_de_passe": hacher_mot_de_passe(mot_de_passe),
            "role": role
        })
        with open(self.fichier_utilisateurs, "w", encoding="utf-8") as f:
            json.dump(data, f, indent=4)

    def log_action(self, action):
        with open(self.fichier_logs, "a", encoding="utf-8") as f:
            f.write(f"{datetime.now()} - {action}\n")

⚠️ Important : si des utilisateurs existent déjà avec l’ancienne version (mot de passe en clair dans utilisateurs.json), ils devront être recréés une fois — les anciens mots de passe en clair ne seront plus reconnus par verifier_mot_de_passe, qui attend désormais un format « sel:hachage ».

[Auteur]

Messages