La détection et la classification des logiciels malveillants sont parmi les domaines de la cybersécurité qui évoluent le plus rapidement et qui sont les plus critiques. Le nombre considérable d'attaques de logiciels malveillants et la sophistication croissante de leurs variantes rendent leur détection en temps opportun un défi de plus en plus croissant.
Alors que les approches traditionnelles de détection des logiciels malveillants peinent à évoluer avec efficacité et précision, les chercheurs se tournent vers le calcul quantique et l'apprentissage machine quantique (QML) comme des percées potentielles. Cet article technique explore l'état actuel de la classification des logiciels malveillants en utilisant des méthodes quantiques, comprenant des explications techniques, des applications réelles, des exemples de code et des conseils d'intégration pour les professionnels de la cybersécurité. Que vous soyez nouveau dans le calcul quantique ou un praticien avancé, cet article offre des perspectives exploitables optimisées pour l'apprentissage et la mise en œuvre pratique.
Les logiciels malveillants — logiciels conçus pour perturber, endommager ou accéder sans autorisation à des systèmes — existent sous d'innombrables formes et tailles : virus, vers, ransomwares, chevaux de Troie, logiciels espions, et plus encore. Chaque année, les fournisseurs de sécurité détectent des millions de nouveaux échantillons, dont beaucoup sont obfusqués ou mutés pour échapper à la détection.
Les systèmes traditionnels basés sur les signatures manquent de dynamique pour suivre le rythme, tandis que les solutions basées sur l'apprentissage machine (ML) sont limitées par des goulots d'étranglement computationnels et nécessitent des réformations en temps opportun à mesure que les logiciels malveillants évoluent.
La détection des logiciels malveillants basée sur l'apprentissage machine suit généralement ce pipeline :
Bien que le ML ait amélioré les taux de détection, il présente des défis :
L'apprentissage machine quantique promet de répondre à certains de ces goulots d'étranglement computationnels et de scalabilité.
Les ordinateurs quantiques exploitent les lois de la mécanique quantique pour traiter l'information. Contrairement aux ordinateurs classiques qui utilisent des bits sous forme binaire 0 ou 1, les ordinateurs quantiques utilisent des qubits qui peuvent être dans des superpositions des deux états. Cela permet à certaines classes de problèmes d'être résolus exponentiellement plus rapidement qu'avec des algorithmes classiques.
Références : arXiv:2510.06803v1, IEEEXplore 10191964
Les QNN combinent des architectures de réseaux de neurones avec des circuits quantiques, permettant d'exploiter le parallélisme quantique pour des tâches comme la classification et la régression. Pour la détection des logiciels malveillants, cela signifie potentiellement classer des variantes complexes plus efficacement.
Référence de l'Article :
Dans cet article, nous adoptons le Réseau de Neurones Quantique (QNN), un sous-ensemble du QML pour la classification et la détection des logiciels malveillants. (ACM Digital Library, 2023)
La plupart des recherches quantiques aujourd'hui sont menées via des environnements basés sur le cloud tels que Google Colab, utilisant des simulateurs quantiques et des bibliothèques QML comme Qiskit d'IBM, PennyLane, ou le SDK Amazon Braket.
Supposons que nous avons extrait des caractéristiques statiques (par exemple, appels API, informations d'en-tête) d'un ensemble de fichiers PE Windows.
# Installer les bibliothèques quantiques essentielles
!pip install qiskit pennylane
import numpy as np
import pennylane as qml
# Définir le dispositif quantique
n_qubits = 4
dev = qml.device("default.qubit", wires=n_qubits)
def quantum_circuit(inputs, weights):
# Encoder les caractéristiques d'entrée dans les portes de rotation
for i in range(n_qubits):
qml.RY(np.pi * inputs[i], wires=i)
# Ajouter une couche d'intrication
for i in range(n_qubits - 1):
qml.CNOT(wires=[i, i+1])
# Appliquer les poids entraînables dans de nouvelles portes de rotation
qml.templates.BasicEntanglerLayers(weights, wires=range(n_qubits))
return qml.expval(qml.PauliZ(0)) # Sortie sur le premier qubit
# Modèle QNN
n_layers = 3
weight_shapes = {"weights": (n_layers, n_qubits)}
qlayer = qml.qnn.KerasLayer(quantum_circuit, weight_shapes, output_dim=1)
# Intégrer dans un réseau de neurones hybride (avec TensorFlow)
import tensorflow as tf
inputs = tf.keras.Input(shape=(n_qubits,))
outputs = qlayer(inputs)
model = tf.keras.Model(inputs=inputs, outputs=outputs)
model.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"])
# `X_train` et `y_train` sont vos échantillons de logiciels malveillants (1) / bénins (0)
model.fit(X_train, y_train, epochs=10, batch_size=16, verbose=2)
predictions = model.predict(X_test) # Sortie la probabilité de logiciels malveillants
Cet exemple simple démontre l'intégration de réseaux de neurones quantiques pour la classification binaire de logiciels malveillants dans un environnement Python adapté à la simulation quantique.
Les Machines à Vecteurs de Support Quantique (QSVM) sont des versions améliorées quantiques des SVM classiques, utilisant des circuits quantiques pour évaluer plus efficacement les fonctions noyau, ce qui est crucial pour les ensembles de données de logiciels malveillants non linéaires et à haute dimension.
Encodage des Données : Les caractéristiques d'entrée des logiciels malveillants sont encodées en états quantiques.
Évaluation du Noyau Quantique : La fonction noyau, mesurant la similarité entre les échantillons, est calculée par un dispositif/circuit quantique.
Classification : Une routine SVM classique utilise le noyau quantique calculé.
Références : arXiv:2510.06803v1
Utilisons Qiskit pour démontrer un QSVM basé sur un noyau pour un ensemble de données de logiciels malveillants.
# Installer les bibliothèques requises
!pip install qiskit scikit-learn pandas
from qiskit import BasicAer
from qiskit.utils import algorithm_globals
from qiskit_machine_learning.kernels import QuantumKernel
from qiskit_machine_learning.algorithms import QSVC
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
# Supposons que vous ayez des données CSV avec des caractéristiques
data = pd.read_csv('malware_features.csv')
X = data.drop('label', axis=1).values
y = data['label'].values
# Normaliser les caractéristiques
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
# Diviser les données
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2)
from qiskit.circuit.library import ZZFeatureMap
feature_map = ZZFeatureMap(feature_dimension=X_train.shape[1], reps=2)
# Noyau quantique
quantum_kernel = QuantumKernel(feature_map=feature_map, quantum_instance=BasicAer.get_backend('qasm_simulator'))
# Classificateur QSVM
qsvc = QSVC(quantum_kernel=quantum_kernel)
qsvc.fit(X_train, y_train)
# Prédire les logiciels malveillants
y_pred = qsvc.predict(X_test)
Remarque : Sur les véritables dispositifs quantiques, utilisez moins de caractéristiques en raison des contraintes matérielles.
Les modèles quantiques peuvent être plus opaques (boîte noire) que le ML classique. Ainsi, l'expliquabilité dans le QML est un domaine de recherche clé, en particulier dans les domaines à fort enjeux comme la cybersécurité.
L'expliquabilité répond à :
Deux méthodes populaires, adoptées dans IEEEXplore 10191964 :
import numpy as np
def feature_importance(qsvc, X_sample):
baseline = qsvc.decision_function([X_sample])
importances = []
for i in range(len(X_sample)):
X_perturbed = X_sample.copy()
X_perturbed[i] = 0 # Mise à zéro de la i-ème caractéristique
imp = abs(baseline - qsvc.decision_function([X_perturbed]))
importances.append(imp)
return importances
fi = feature_importance(qsvc, X_test[0])
print("Importances des caractéristiques :", fi)
La plupart des organisations s'appuient sur des pipelines automatisés pour l'analyse, l'analyse et le reporting des logiciels malveillants. L'intégration des modèles quantiques implique l'extraction de caractéristiques à partir des fichiers de logiciels malveillants, leur prétraitement, puis leur alimentation vers un modèle quantique.
pefile pour les fichiers PE Windows)# Lister tous les échantillons dans un répertoire
ls samples/ > filelist.txt
# Extraire les caractéristiques en lot à l'aide de Python
python extract_features.py --input filelist.txt --output malware_features.csv
extract_features.pyimport pefile
import pandas as pd
import sys
files = open(sys.argv[2]).read().splitlines()
features = []
for file in files:
try:
pe = pefile.PE(file)
num_sections = len(pe.sections)
entropy = [s.get_entropy() for s in pe.sections]
imports = len(pe.DIRECTORY_ENTRY_IMPORT)
size = pe.OPTIONAL_HEADER.SizeOfImage
label = 1 if 'malicious' in file else 0 # Logique factice
features.append([num_sections, np.mean(entropy), imports, size, label])
except Exception as e:
print(f"Erreur lors du traitement de {file} : {e}")
pd.DataFrame(features, columns=['num_sections', 'entropy', 'imports', 'size', 'label']).to_csv(sys.argv[4], index=False)
Supposons que vous ayez utilisé ClamAV pour l'analyse de lot :
clamscan -r samples/ --infected --no-summary > scan_results.txt
infected_files = []
with open('scan_results.txt') as f:
for line in f:
if "FOUND" in line:
fname = line.split(':')[0]
infected_files.append(fname)
Vous pouvez utiliser le malware_features.csv résultant comme entrée pour les modèles QNN ou QSVM ci-dessus en extrayant les caractéristiques et les étiquettes en conséquence.
Les logiciels malveillants polymorphes changent leur signature de code à chaque tentative d'infection tout en conservant le comportement sous-jacent. En utilisant les QNN entraînés sur les modèles de fréquence des opcodes, les chercheurs ont obtenu des taux de détection supérieurs même contre des ransomwares et chevaux de Troie extrêmement obfusqués par rapport aux réseaux neuronaux classiques.
Les logiciels malveillants basés sur des macros (par exemple, documents Office malveillants) intègrent souvent une logique complexe. Un classificateur à noyau quantique (QSVM) utilisant les caractéristiques extraites de la structure du document, la fréquence des opcodes macro, et les graphes d'appels VBA a pu discerner de nouveaux échantillons de logiciels malveillants macro avec des taux de vrais positifs plus élevés que les SVM classiques dans des ensembles de données du monde réel.
Les Centres d'Opérations de Sécurité (COS) ont intégré des classificateurs améliorés par les quanta dans les pipelines de SIEM (Gestion des Informations et des Événements de Sécurité), déclenchant des alertes en temps réel lorsque les échantillons entrants correspondant à des signatures quantiques à haut risque.
L'apprentissage machine quantique — en particulier les Réseaux de Neurones Quantiques et les Machines à Vecteurs de Support Quantiques — représente une avancée de pointe dans la détection et la classification des logiciels malveillants. Bien qu'elles en soient encore à un stade précoce, ces approches ont démontré des améliorations dans la reconnaissance des schémas de logiciels malveillants complexes et l'amélioration de la détection des échantillons adversariaux.
En combinant une ingénierie robuste des caractéristiques, une automatisation classique (Bash/Python) et des algorithmes quantiques, les équipes de cybersécurité peuvent commencer à expérimenter le QML et se préparer à l'ère à venir de la défense cyber accélérée par le quantique.
ACM Digital Library. “Classification et Détection de Logiciels Malveillants Utilisant le Réseau de Neurones Quantique,” 2023.
https://dl.acm.org/doi/10.1145/3545947.3573288
préimpression arXiv. “Méthodes de Calcul Quantique pour la Détection de Logiciels Malveillants,” 2024.
https://arxiv.org/html/2510.06803v1
IEEE Xplore. “Exploration de l'Apprentissage Machine Quantique pour la Détection de Logiciels Malveillants Explicable,” 2023.
https://ieeexplore.ieee.org/document/10191964/
Documentation Qiskit.
https://qiskit.org/documentation/
Documentation PennyLane.
https://docs.pennylane.ai/
Documentation Scikit-learn.
https://scikit-learn.org/stable/
Site Officiel ClamAV.
https://www.clamav.net/
Pour les codes mis à jour et les tutoriels, visitez les sites officiels de Qiskit (https://qiskit.org/) et PennyLane (https://pennylane.ai/). Pour des études de cas plus détaillées et des guides d'intégration, voir les articles académiques référencés ci-dessus.
Si vous avez trouvé ce contenu utile, imaginez ce que vous pourriez accomplir avec notre programme de formation élite complet de 47 semaines. Rejoignez plus de 1 200 étudiants qui ont transformé leur carrière grâce aux techniques de l'Unité 8200.