Il presente articolo è stato tradotto automaticamente.
Esecuzione di test
Sistemi immunitari artificiali per il rilevamento delle intrusioni
.jpg)
Un sistema immunitario artificiale (AIS) per il rilevamento delle intrusioni è un sistema software che modella alcune parti del comportamento del sistema immunitario umano per proteggere le reti di computer da virus e attacchi informatici simili. L'idea fondamentale è che il sistema immunitario umano — che è un sistema complesso costituito da linfociti (globuli bianchi), anticorpi e molti altri componenti — si è evoluto nel tempo a fornire una potente protezione contro le tossine dannose e altri agenti patogeni. Così, modellare il comportamento del sistema immunitario umano può fornire un'architettura efficacia contro attacchi informatici.
In questo articolo descritti alcuni dei principi del sistema immunitario artificiale e presentare un programma per dimostrare questi principi. Lavoro sulla protezione AIS è ancora relativamente nuova e, a mio parere, non le implementazioni commerciali sono abbastanza pronte per il primo tempo. Il codice presentato in questo articolo non direttamente vi permetterà di creare un sistema realistico di intrusione di rete, ma ci sono almeno quattro ragioni perché si potrebbe trovare questo articolo vale la pena leggere. In primo luogo, il codice vi darà un punto di partenza per la sperimentazione hands-on con un semplice sistema AIS. In secondo luogo, i principi spiegati si otterrà oltre l'ostacolo iniziale piuttosto difficile a quest'area e consentono di capire research papers su AIS. In terzo luogo, molte delle tecniche di programmazione utilizzate in questo articolo, in particolare pezzi r bit corrispondenti e selezione negativa, può essere utile in altri scenari di programmazione. E in quarto luogo, si possa trovare solo l'idea di modellare un sistema software basato sul comportamento del sistema immunitario umano interessante nella sua propria destra.
Il modo migliore per avere un'idea di dove sono diretto è di dare un'occhiata alla schermata di un demo run, mostrato Figura 1. Il programma demo inizia con la creazione di un set di sei normale pattern (modelli che sono noti per non far parte di qualche cyber attacco) TCP/IP che rappresentano i pacchetti in formato binario di rete. Questo è chiamato l'infissi nella terminologia AIS. Naturalmente, in un vero e proprio sistema AIS, gli infissi sarebbero probabilmente contenere decine o centinaia di migliaia di modelli, e ogni modello sarebbe molto più grande (in genere 48-256 bit) più i 12 bit usati qui. Successivamente, il programma demo crea tre linfociti artificiale. Ogni linfocita ha un anticorpo simulato che ha quattro bit (nuovo, artificialmente piccolo), un'età e un campo di stimolazione. Il campo dell'anticorpo è essenzialmente un rivelatore. Come vedrà a breve, i linfociti sono creati in modo che nessuno di loro rilevare qualsiasi dei modelli negli infissi. Per ora, osservare che ogni linfocita ha tre zeri consecutivi o 1s, ma nessuno dei modelli nell'infissi ha tre valori di bit uguali consecutivi.
.png)
Figura 1 Demo sistema immunitario artificiale
Dopo che il sistema è stato inizializzato, il programma demo inizia una piccola simulazione con sei modelli di input. Il primo input viene rilevato da linfocita 1, ma perché ogni linfocita ha una soglia di attivazione, i linfociti non si innescano un allarme. Al tempo t = 3, 1 linfocita rileva un altro ingresso sospettoso ma, ancora una volta, non è ancora oltre la soglia. Ma al tempo t = 5, linfocita 1 rileva un terzo pacchetto ingresso sospettoso e viene attivato un allarme simulato.
Nelle sezioni che seguono, mi spiego prima i concetti chiave del sistema immunitario umano che vengono utilizzati per modellare un AIS. Poi ti guiderò attraverso il codice che ha prodotto lo screenshot in Figura 1. Concluderò dandovi alcuni riferimenti aggiuntivi e alcune opinioni su AIS. Questo articolo si presuppone almeno a livello intermedio competenze di programmazione con un linguaggio di programmazione moderno. Utilizzare c# per il programma demo, ma ti spiego dove dovrai apporta modifiche se si desidera effettuare il refactoring mio codice in un altro linguaggio, ad esempio Visual Basic .NET o Python. Ho presente tutto il codice che ha generato lo screenshot in Figura 1; il codice è anche disponibile presso archive.msdn.microsoft.com/mag201301TestRun.
Il sistema immunitario umano
Gli elementi chiave di un sistema immunitario altamente semplificato sono illustrati Figura 2. Elementi nocivi sono proteine chiamate antigeni. In Figura 2 gli antigeni sono di colore rosso e hanno spigoli vivi. Anche il corpo umano contiene molti antigeni non nocivi chiamati auto-antigeni, o self-items. Queste proteine sono naturalmente e in Figura 2 sono di colore verde e hanno arrotondato i lati.
.png)
Figura 2 elementi chiave di un sistema immunitario semplificato
Gli antigeni vengono rilevati dai linfociti. Ogni linfocita ha diversi anticorpi, che possono essere pensati come rivelatori. Ogni anticorpo è specifico per un antigene particolare. In genere, perché è solo approssimativa dell'anticorpo-antigene corrispondente, un linfocita non si innescherà una reazione quando un singolo anticorpo rileva un singolo antigene. Solo dopo parecchi anticorpi rilevare loro antigeni corrispondenti un linfocita diventerà stimolato e innescare una sorta di reazione difensiva.
Si noti che dei linfociti ha anticorpi che rilevano un self-item. Reali anticorpi generati dal sistema immunitario nel timo, ma eventuali anticorpi che rilevare self-items vengono distrutti prima di essere rilasciato nel flusso sanguigno, un processo chiamato apoptosi.
In termini di un sistema di rilevamento delle intrusioni, antigeni corrispondono ai pacchetti di rete TCP/IP cui contenuto contenga una sorta di dati dannosi, ad esempio un virus informatico. Auto-antigeni corrispondono ai pacchetti di rete normale, non nocivo. Un anticorpo corrisponde a uno schema di bit che corrisponde circa a un pacchetto di rete sconosciuto, potenzialmente dannosi. Un linfocita rappresenta due o più anticorpi/rivelatori. Apoptosis è modellato utilizzando una tecnica chiamata selezione negativa.
Struttura generale del programma
Il programma demo mostrato Figura 1 è una singola applicazione console c# denominata ArtificialImmuneSystem. Ho usato Visual Studio 2010, ma dovrebbe funzionare qualsiasi versione di Visual Studio che è il Microsoft .NET Framework 2.0 o versione successiva. Ho rinominato il file generato da modelli Visual Studio denominato Program. cs per il ArtificialImmuneSystemProgram.cs più descrittivo e rinominato come pure la classe corrispondente. La struttura generale del programma è elencata Figura 3.
Figura 3 struttura di programma di sistema immunitario artificiale
using System;
using System.Collections.Generic;
using System.Collections; // for BitArray
namespace ArtificialImmuneSystem
{
class ArtificialImmuneSystemProgram
{
static Random random;
static void Main(string[] args)
{
Console.WriteLine("\nBegin Artificial Immune System for Intrusion" +
" Detection demo\n");
random = new Random(1);
int numPatternBits = 12;
int numAntibodyBits = 4;
int numLymphocytes = 3;
int stimulationThreshold = 3;
Console.WriteLine("Loading self-antigen set ('normal' historical patterns)");
List<BitArray> selfSet = LoadSelfSet(null);
ShowSelfSet(selfSet);
Console.WriteLine("\nCreating lymphocyte set using negative selection" +
" and r-chunks detection");
List<Lymphocyte> lymphocyteSet = CreateLymphocyteSet(selfSet, numAntibodyBits,
numLymphocytes);
ShowLymphocyteSet(lymphocyteSet);
Console.WriteLine("\nBegin AIS intrusion detection simulation\n");
int time = 0;
int maxTime = 6;
while (time < maxTime)
{
Console.WriteLine("============================================");
BitArray incoming = RandomBitArray(numPatternBits);
Console.WriteLine("Incoming pattern = " +
BitArrayAsString(incoming) + "\n");
for (int i = 0; i < lymphocyteSet.Count; ++i)
{
if (lymphocyteSet[i].Detects(incoming) == true)
{
Console.WriteLine("Incoming pattern detected by lymphocyte " + i);
++lymphocyteSet[i].stimulation;
if (lymphocyteSet[i].stimulation >= stimulationThreshold)
Console.WriteLine("Lymphocyte " + i + " stimulated!" +
" Check incoming as possible intrusion!");
else
Console.WriteLine("Lymphocyte " + i + " not over stimulation" +
" threshold");
}
else
Console.WriteLine("Incoming pattern not detected by lymphocyte " + i);
}
++time;
Console.WriteLine("============================================");
} // Simulation loop
Console.WriteLine("\nEnd AIS IDS demo\n");
Console.ReadLine();
} // Main
public static List<BitArray> LoadSelfSet(string dataSource) {..}
public static void ShowSelfSet(List<BitArray> selfSet) {..}
public static string BitArrayAsString(BitArray ba) {..}
public static List<Lymphocyte> CreateLymphocyteSet(List<BitArray> selfSet,
int numAntibodyBits, int numLymphocytes) {..}
private static bool DetectsAny(List<BitArray>
selfSet, Lymphocyte lymphocyte) {..}
public static void ShowLymphocyteSet(List<Lymphocyte> lymphocyteySet) {..}
public static BitArray RandomBitArray(int numBits) {..}
} // Program
public class Lymphocyte
{
public BitArray antibody; // detector
public int[] searchTable; // for fast detection
public int age; // not used; could determine death
public int stimulation; // controls triggering
public Lymphocyte(BitArray antibody) {..}
private int[] BuildTable() {..}
public bool Detects(BitArray pattern) {..}
public override int GetHashCode() {..}
public override string ToString() {..}
}
} // ns
Ho eliminato tutto il modello generato utilizzando dichiarazioni fatta eccezione per i riferimenti a spazi dei nomi System e System.Collections.Generic. Ho aggiunto un riferimento allo spazio dei nomi System. Collections, così ho potuto avere accesso alla classe BitArray. Dopo un messaggio di avvio, istanziato un oggetto Random statico utilizzando un valore di inizializzazione arbitrario di 1.
Se si confronta il codice nel metodo Main Figura 3 con lo screenshot in Figura 1, non dovreste avere troppi problemi a comprendere la logica del programma. La chiave per la demo di AIS è la definizione della classe dei linfociti. Si noti che, al fine di mantenere le dimensioni del codice demo piccolo e chiaro le idee chiave, ho rimosso tutto il normali controllo errori che probabilmente includere durante la sperimentazione.
La classe dei linfociti
La classe dei linfociti ha quattro campi di dati:
public BitArray antibody; // Detector
public int[] searchTable; // For fast detection
public int age; // Not used; could determine death
public int stimulation; // Controls triggering
Dichiaro che tutti i campi con ambito pubblico per semplicità. Il campo dell'anticorpo è una classe BitArray. Se non hai familiarità con BitArray, l'idea è che utilizzando un normale array di int per rappresentare un insieme di bit è altamente inefficiente perché ogni int richiede 32 bit di memoria. Un array di bit si condensa a 32 bit di informazioni in un singolo int di archiviazione più overhead per la classe. Linguaggi di programmazione che non hanno una classe BitArray-come richiedono di fare la manipolazione dei bit di basso livello con bit masking e operazioni bit.
Il campo searchTable è una matrice che viene utilizzata dal metodo rileva per aumentare notevolmente le prestazioni. Il campo di età non è utilizzato nel mio programma demo; molti sistemi AIS traccia l'età di un linfocita simulato e probabilisticamente uccidono e generano nuovi linfociti basati sull'età. Il campo di stimolazione è un contatore che tiene traccia di quante volte un oggetto linfocita ha rilevato una possibile minaccia. In questa demo, quando un valore di stimolazione dei linfociti supera il valore di stimulationThreshold di 3, viene attivato un allarme.
Il costruttore dei linfociti è:
public Lymphocyte(BitArray antibody)
{
this.antibody = new BitArray(antibody);
this.searchTable = BuildTable();
this.age = 0;
this.stimulation = 0;
}
Il costruttore accetta un singolo parametro BitArray che rappresenta un antigene/rivelatore. La matrice searchTable viene creata un'istanza utilizzando un metodo di supporto privato denominato BuildTable, che ti presento subito.
Una delle parti fondamentali di qualsiasi sistema AIS è la routine che determina se un antigene rileva un pattern. Che richiede una corrispondenza esatta non è fattibile (e non imitare il comportamento reale dell'antigene). Primi lavori su AIS utilizzato una tecnica chiamata bit r-contigui di corrispondenza, in cui un antigene e un modello di input di avere lo stesso numero di bit e rilevamento si verifica quando l'antigene e pattern match in bit consecutivi-r. Ricerca successiva ha indicato che un migliore algoritmo di rilevamento è r-pezzi bit corrispondenti. il r-pezzi bit corrispondenti è simile a bit r-contigui corrispondente ad eccezione del fatto che il rivelatore di antigene è minore il pattern di controllo e rilevazione si verifica quando l'antigene corrisponde a sottoinsieme di ny del pattern. Ad esempio, se un modello è 000110111 e un antigene è 110, l'antigene rileva il pattern a partire dall'indice 3.
Se pensi di r-pezzi di corrispondenza per un attimo, vi renderete conto che è quasi la stessa di una funzione di sottostringa della stringa. L'unica differenza sono che r-blocchi corrispondenti bit partite e sottostringa corrisponde ai caratteri.
Nell'esempio precedente, un approccio semplice per r-blocchi corrispondenti sarebbe quello di esaminare il pattern a partire dall'indice 0, quindi dall'indice 1, poi 2 e così via. Tuttavia, questo approccio è molto lento nella maggior parte delle situazioni. Esistono diversi algoritmi sofisticati sottostringa che elabora la stringa rivelatore più piccola per creare una matrice (di solito chiamata un tavolo). Questa tabella di ricerca può essere utilizzata per saltare avanti quando viene rilevata una mancata corrispondenza e migliorare notevolmente le prestazioni. In situazioni dove la stringa rivelatore più piccola viene ripetutamente utilizzata per controllare diversi modelli — come nel rilevamento delle intrusioni AIS — il tempo e la memoria necessaria per creare la tabella di ricerca è un piccolo prezzo da pagare per le prestazioni notevolmente migliorate.
Il metodo rileva dei linfociti classe utilizza l'algoritmo di Knuth-Morris-Pratt sottostringa applicato a una classe BitArray. Il metodo rileva accetta un input pattern come 000110111 e restituisce true se l'antigene dell'oggetto corrente, ad esempio 110, corrisponde al modello. Il codice per il metodo rileva è elencato Figura 4.
Figura 4 il metodo di rileva
public bool Detects(BitArray pattern) // Adapted KMP algorithm
{
int m = 0;
int i = 0;
while (m + i < pattern.Length)
{
if (this.antibody[i] == pattern[m + i])
{
if (i == antibody.Length - 1)
return true;
++i;
}
else
{
m = m + i - this.searchTable[i];
if (searchTable[i] > -1)
i = searchTable[i];
else
i = 0;
}
}
return false; // Not found
}
Il metodo rileva presuppone l'esistenza della tabella di ricerca. Ricordiamo che il costruttore dei linfociti chiama un metodo di supporto BuildTable per creare il campo di searchTable. Il codice per BuildTable è elencato Figura 5.
Figura 5 il metodo BuildTable
private int[] BuildTable()
{
int[] result = new int[antibody.Length];
int pos = 2;
int cnd = 0;
result[0] = -1;
result[1] = 0;
while (pos < antibody.Length)
{
if (antibody[pos - 1] == antibody[cnd])
{
++cnd; result[pos] = cnd; ++pos;
}
else if (cnd > 0)
cnd = result[cnd];
else
{
result[pos] = 0; ++pos;
}
}
return result;
}
La classe dei linfociti definisce merthods sottoposta a override di GetHashCode e ToString. Il metodo GetHashCode viene utilizzato per impedire che oggetti duplicati dei linfociti ed è:
public override int GetHashCode()
{
int[] singleInt = new int[1];
antibody.CopyTo(singleInt, 0);
return singleInt[0];
}
Questa implementazione si presuppone che il campo di anticorpo BitArray ha 32 bit o meno. In situazioni realistiche, dove il campo dell'anticorpo ha più di 32 bit, si occupano di oggetti duplicati dei linfociti non è così semplice. Un approccio sarebbe quello di definire un metodo di codice hash personalizzato che restituisce un tipo BigInteger (disponibile in .NET Framework 4 e versioni successive).
Il metodo ToString di linfociti utilizzato nel programma demo è:
public override string ToString()
{
string s = "antibody = ";
for (int i = 0; i < antibody.Length; ++i)
s += (antibody[i] == true) ? "
1 " : "0 ";
s += " age = " + age;
s += " stimulation = " + stimulation;
return s;
}
Creando gli infissi
Siete certamente familiarità con standard (non-AIS) software computer antivirus come Microsoft Security Essentials. Questi sistemi funzionano memorizzando un database locale delle definizioni di virus computer conosciuto. Quando viene rilevato un pattern virus conosciuto, viene attivato un allarme immediato. Tali sistemi antivirus hanno problemi affrontare variazioni su virus esistenti e non interamente nella maggior parte delle situazioni, quando di fronte a un virus completamente nuovo. Rilevamento delle intrusioni AIS funziona in modo opposto mantenendo un insieme di modelli di input che sono noti per essere non nocivo e quindi innescando un allarme quando viene rilevato un motivo sconosciuto. Questo consente ai sistemi di rilevamento delle intrusioni AIS — in linea di principio, almeno, di rilevare nuovi virus. Tuttavia, si tratta di falsi positivi — cioè, innescando un avviso su un modello di input di non nocivo — è una grande sfida per i sistemi AIS.
Un sistema di rilevamento delle intrusioni AIS reale sarebbe raccogliere molte migliaia di modelli di ingresso normale nel corso di giorni o settimane. Questi modelli di infissi normale saranno memorizzati sia su un host locale o un server. Inoltre, un vero e proprio sistema AIS sarebbe continuamente aggiornare gli infissi (e il set indotto dei linfociti) dei normali modelli a rendere conto delle normali variazioni nel traffico di rete nel tempo. Il programma demo in questo articolo crea un artificiale, statica self-set utilizzando il metodo LoadSelfSet:
public static List<BitArray> LoadSelfSet(string dataSource)
{
List<BitArray> result = new List<BitArray>();
bool[] self0 = new bool[] { true, false, false, true, false, true,
true, false, true, false, false, true };
// Etc.
bool[] self5 = new bool[] { false, false, true, false, true, false,
true, false, false, true, false, false };
result.Add(new BitArray(self0));
// Etc.
result.Add(new BitArray(self5));
return result;
}
Il metodo accetta un parametro fittizio dataSource non usato per suggerire che in uno scenario realistico i dati infissi non sarebbero hardcoded. Costruttore BitArray, piuttosto sorprendentemente, accetta una matrice di valori Boolean dove true rappresenta un bit 1 e false rappresenta un bit 0. Osservare che generato i dati infissi in modo che non self-item ha più di due zeri consecutivi o 1s.
Il programma demo utilizza il metodo di utilità ShowSelfSet, che chiama il metodo di supporto BitArrayAsString, per visualizzare gli infissi:
public static void ShowSelfSet(List<BitArray> selfSet)
{
for (int i = 0; i < selfSet.Count; ++i)
Console.WriteLine(i + ": " + BitArrayAsString(selfSet[i]));
}
public static string BitArrayAsString(BitArray ba)
{
string s = "";
for (int i = 0; i < ba.Length; ++i)
s += (ba[i] == true) ? "
1 " : "0 ";
return s;
}
Creare l'insieme dei linfociti
Se si fa riferimento nuovamente la spiegazione di come funziona il sistema immunitario umano, si noterà che il set dei linfociti deve contenere solo gli oggetti dei linfociti non rilevare eventuali modelli negli infissi. Metodo CreateLymphocyteSet è elencato Figura 6.
Figura 6 il metodo CreateLymphocyteSet
public static List<Lymphocyte> CreateLymphocyteSet(List<BitArray> selfSet,
int numAntibodyBits, int numLymphocytes)
{
List<Lymphocyte> result = new List<Lymphocyte>();
Dictionary<int, bool> contents = new Dictionary<int, bool>();
while (result.Count < numLymphocytes)
{
BitArray antibody = RandomBitArray(numAntibodyBits);
Lymphocyte lymphocyte = new Lymphocyte(antibody);
int hash = lymphocyte.GetHashCode();
if (DetectsAny(selfSet, lymphocyte) == false &&
contents.ContainsKey(hash) == false)
{
result.Add(lymphocyte);
contents.Add(hash, true);
}
}
return result;
}
Nella terminologia AIS, metodo CreateLymphocyteSet utilizza la selezione negativa. Un linfocita casuale oggetto viene generato e quindi sottoposti a test per vedere se non rileva alcun pattern gli infissi, e anche che il linfocita non è già nel risultato impostato. Questo approccio è piuttosto grezzo, e ci sono altri approcci che sono più efficienti. Utilizzare un dizionario insieme con un valore Boolean fittizio per tenere traccia degli oggetti esistenti dei linfociti; HashSet nel .NET Framework 4.5 e successive è un'alternativa più efficiente.
Generando una classe BitArray casuale viene creato un oggetto casuale di linfociti:
public static BitArray RandomBitArray(int numBits)
{
bool[] bools = new bool[numBits];
for (int i = 0; i < numBits; ++i)
{
int b = random.Next(0, 2); // between [0,1] inclusive
bools[i] = (b == 0) ?
false : true;
}
return new BitArray(bools);
}
Metodo Helper DetectsAny accetta un infissi e un linfocita analizza attraverso un infissi e restituisce true se l'antigene del linfocita rilevano qualsiasi modello nell'infissi:
private static bool DetectsAny(List<BitArray> selfSet,
Lymphocyte lymphocyte)
{
for (int i = 0; i < selfSet.Count; ++i)
if (lymphocyte.Detects(selfSet[i]) == true) return true;
return false;
}
Il programma demo utilizza un metodo di utilità ShowLymphocyteSet per visualizzare gli oggetti generati dei linfociti:
public static void ShowLymphocyteSet(List<Lymphocyte> lymphocyteySet)
{
for (int i = 0; i < lymphocyteySet.Count; ++i)
Console.WriteLine(i + ": " + lymphocyteySet[i].ToString());
}
Conclusioni
Il codice e le spiegazioni che ho presentato in questo articolo vi darà una solida base per la sperimentazione hands-on con un AIS.I ricercatori hanno suggerito molte opzioni.Ad esempio, il programma demo in questo articolo viene generato un avviso quando un singolo linfocita rileva sconosciuto pattern di input più alcuni soglia numero di volte.L'idea qui è che i veri agenti patogeni emettono molti antigeni.Un'altra possibilità è il sistema AIS attivare un avviso solo dopo molteplici differenti linfociti rileva lo stesso modello sconosciuto.
È importante sottolineare che un AIS non è destinato ad essere un'unica soluzione per il rilevamento delle intrusioni.Piuttosto, è destinata ad essere parte di una difesa multistrata che include un software antivirus tradizionale.Inoltre, perché il lavoro con un AIS è ancora relativamente giovane, ci sono molte domande senza risposta.Se si desidera esaminare alcune ricerche su AIS, vi consiglio di ricerca on-line di articoli di autori S.Forrest, P.Williams e U.Aickelin.
Dr. James McCaffrey funziona per Volt Information Sciences Inc., dove gestisce la formazione tecnica per gli ingegneri software della Microsoft di Redmond, Washington, campus. Si è occupato di diversi prodotti Microsoft, inclusi Internet Explorer e MSN Search. McCaffrey è l'autore di ".NET Test Automation Recipes" (Apress, 2006). Può essere raggiunto a jammc@microsoft.com.
Grazie all'esperto tecnica seguente per la revisione di questo articolo: Dan Liebling