Upload 4 files

Dockerfile

@@ -0,0 +1,19 @@
+# Utiliser une image officielle Python comme base
+FROM python:3.9-slim
+
+# Définir le répertoire de travail dans le conteneur
+WORKDIR /app
+
+# Copier les fichiers nécessaires dans le conteneur
+COPY . /app
+
+# Installer les dépendances
+RUN pip install --upgrade pip \
+    && pip install -r requirements.txt
+
+# Exposer le port par défaut de Streamlit
+EXPOSE 8501
+
+# Définir la commande pour lancer l'application Streamlit
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+

app.py

@@ -0,0 +1,134 @@
+import os
+import joblib
+import pefile
+import numpy as np
+import pandas as pd
+import streamlit as st
+import hashlib
+import traceback
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, recall_score
+
+# Chemin vers le modèle sauvegardé
+MODEL_PATH = 'random_forest_model.pkl'
+
+# Fonction pour entraîner et sauvegarder le modèle
+def train_and_save_model():
+    """Entraîner et sauvegarder le modèle si nécessaire."""
+    st.write("Aucun modèle trouvé. Entraînement en cours...")
+    # Chargement des données
+    data = pd.read_csv("DatasetmalwareExtrait.csv")
+
+    # Traitement des données
+    X = data.drop(['legitimate'], axis=1)
+    y = data['legitimate']
+
+    # Entraînement du modèle
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+    model = RandomForestClassifier(
+        n_estimators=196,
+        random_state=42,
+        criterion="gini",
+        max_depth=25,
+        min_samples_split=4,
+        min_samples_leaf=1
+    )
+    model.fit(X_train, y_train)
+
+    # Évaluation du modèle
+    y_pred = model.predict(X_test)
+    accuracy = accuracy_score(y_test, y_pred)
+    recall = recall_score(y_test, y_pred, average='weighted')
+
+    st.write(f"Précision du modèle supervisé : {accuracy:.3f}")
+    st.write(f"Rappel du modèle supervisé : {recall:.3f}")
+
+    # Sauvegarde du modèle
+    joblib.dump(model, MODEL_PATH)
+    st.write(f"Modèle sauvegardé sous : {MODEL_PATH}")
+    return model
+
+# Chargement ou entraînement du modèle
+if os.path.exists(MODEL_PATH):
+    st.write("Chargement du modèle existant...")
+    model = joblib.load(MODEL_PATH)
+else:
+    model = train_and_save_model()
+
+# Fonction pour calculer le hash d'un fichier
+def calculate_file_hash(file_path):
+    """Calculer le hash SHA-256 du fichier."""
+    sha256_hash = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        for byte_block in iter(lambda: f.read(4096), b""):
+            sha256_hash.update(byte_block)
+    return sha256_hash.hexdigest()
+
+# Fonction pour extraire les attributs PE
+def extract_pe_attributes(file_path):
+    """Extraction avancée des attributs du fichier PE."""
+    try:
+        pe = pefile.PE(file_path)
+        attributes = {
+            'AddressOfEntryPoint': pe.OPTIONAL_HEADER.AddressOfEntryPoint,
+            'MajorLinkerVersion': pe.OPTIONAL_HEADER.MajorLinkerVersion,
+            'MajorImageVersion': pe.OPTIONAL_HEADER.MajorImageVersion,
+            'MajorOperatingSystemVersion': pe.OPTIONAL_HEADER.MajorOperatingSystemVersion,
+            'DllCharacteristics': pe.OPTIONAL_HEADER.DllCharacteristics,
+            'SizeOfStackReserve': pe.OPTIONAL_HEADER.SizeOfStackReserve,
+            'NumberOfSections': pe.FILE_HEADER.NumberOfSections,
+            'ResourceSize': pe.OPTIONAL_HEADER.DATA_DIRECTORY[2].Size
+        }
+        return attributes
+    except Exception as e:
+        st.error(f"Erreur de traitement du fichier {file_path}: {str(e)}")
+        return {"Erreur": str(e)}
+
+# Fonction de prédiction
+def predict_malware(file):
+    """Prédiction de malware avec gestion d'erreurs."""
+    if model is None:
+        return "Erreur : Modèle non chargé"
+
+    try:
+        # Sauvegarde temporaire du fichier
+        temp_file = f"temp_{file.name}"
+        with open(temp_file, "wb") as f:
+            f.write(file.read())
+
+        # Extraire les attributs du fichier
+        attributes = extract_pe_attributes(temp_file)
+        if "Erreur" in attributes:
+            return attributes["Erreur"]
+
+        # Convertir en DataFrame
+        df = pd.DataFrame([attributes])
+
+        # Prédiction
+        prediction = model.predict(df)
+        proba = model.predict_proba(df)[0]
+
+        # Résultat avec probabilité
+        if prediction[0] == 1:
+            result = f"🚨 MALWARE (Probabilité: {proba[1] * 100:.2f}%)"
+        else:
+            result = f"✅ Fichier Légitime (Probabilité: {proba[0] * 100:.2f}%)"
+
+        # Suppression du fichier temporaire
+        os.remove(temp_file)
+
+        return result
+    except Exception as e:
+        return f"Erreur d'analyse : {str(e)}"
+
+# Interface Streamlit
+st.title("🛡️ Détecteur de Malwares")
+st.write("Téléchargez un fichier exécutable pour analyser s'il est légitime ou un malware.")
+
+uploaded_file = st.file_uploader("Télécharger un fichier exécutable (.exe, .dll, .sys)", type=["exe", "dll", "sys"])
+
+if uploaded_file is not None:
+    st.write("Analyse en cours...")
+    result = predict_malware(uploaded_file)
+    st.success(result)

requirements.txt

@@ -0,0 +1,6 @@
+joblib==1.3.2
+pefile==2023.2.7
+numpy==1.24.3
+pandas==2.0.3
+streamlit==1.26.0
+scikit-learn==1.3.1