Dieser Artikel wurde maschinell übersetzt.

Test Run

Künstliche Immunsysteme zur Eindringversuchserkennung

James McCaffrey

Künstliches immunes System (AIS) für Intrusion Detection ist ein Softwaresystem, das Modelle einige Teile des Verhaltens des menschlichen Immunsystems Computernetzwerke vor Viren und ähnliche Cyber-Angriffen schützen.Der Grundgedanke ist, dass das menschliche Immunsystem — das ist ein komplexes System, bestehend aus Lymphozyten (weiße Blutkörperchen), Antikörper und viele andere Komponenten — entwickelte sich im Laufe der Zeit leistungsstarken Schutz vor schädlichen Giften und anderen Krankheitserregern.Modellierung des Verhaltens des menschlichen Immunsystems kann, eine effektive Architektur vor Cyber-Angriffen vorgesehen.

In diesem Artikel, die ich beschreiben einige der Grundsätze der künstlichen Immunsystem und präsentieren ein Programm, um diese Grundsätze zu demonstrieren.Arbeit über AIS Schutz ist noch relativ neu und meiner Meinung nach keine kommerziellen Implementierungen sind ganz bereit für Prime-Time.Der Code in diesem Artikel wird nicht direkt können Sie erstellen eine realistische Network-Intrusion-System, aber es gibt mindestens vier Gründe, warum Sie diesen Artikel lesenswert finden könnten.Zuerst geben der Code als Ausgangspunkt für praktische Experimente mit einem einfachen AIS-System Ihnen.Zweitens werden die Grundsätze erläutert erhalten Sie über die recht schwierigen ersten Hürde zu diesem Bereich und ermöglichen es Ihnen, auf AIS-Studien zu verstehen.Drittens können mehrere Techniken der Programmierung in diesem Artikel in bestimmten R-Brocken bisschen matching und negative Selektion, in anderen Programmiersprachen Szenarien hilfreich sein.Und viertens finden Sie nur die Idee der Modellierung eines Softwaresystems basierend auf dem Verhalten des menschlichen Immunsystems aus eigenem Recht interessant.

Der beste Weg, um ein Gefühl für wohin ich bin wird sich einen Blick auf den Screenshot einer Demo laufen, siehe Abbildung 1.Das Demoprogramm beginnt mit dem Erstellen einer Gruppe von sechs normalen Muster (Muster, die als bekannt sind nicht Teil des einige Cyber-Angriff), dass TCP/IP darstellen Netzwerk-Pakete in binärer Form.Dies wird in der Terminologie der AIS der explosiven bezeichnet.Natürlich in einem echten AIS-System, die explosiven würde wahrscheinlich enthalten Dutzende oder Hunderte von Tausenden von Mustern, und jedes Muster wäre viel größer (in der Regel 48-256-Bit) als die hier verwendeten 12 Bits.Anschließend erstellt das Demoprogramm drei künstliche Lymphozyten.Jede Lymphozyte hat ein simulierter Antikörper, der hat vier Bits (wieder, künstlich klein), ein Alter und ein Feld Stimulierung.Das Antikörper-Feld ist im Wesentlichen ein Detektor.Sie werden bald erkennen, werden die Lymphozyten erstellt, so dass keiner von ihnen eines der Muster in der explosiven erkennen.Im Moment beobachten Sie, dass jede Lymphozyte drei aufeinanderfolgende Nullen oder Einsen hat aber keines der Muster in der explosiven gleich drei aufeinander folgenden Bitwerte hat.

Abbildung 1 künstliche Immunsystem Demo

Nachdem das System initialisiert wurde, beginnt das Demoprogramm eine kleine Simulation mit sechs Eingabemuster.Die erste Eingabe von Lymphozyten 1 erkannt wird, aber da jede Lymphozyte eine Aktivierung Schwelle hat, nicht die Lymphozyten einen Alarm auslösen.Zum Zeitpunkt t = 3, 1 Lymphozyte erkennt ein Verdächtiger Input aber auch hier ist noch nicht über die Schwelle.Aber zum Zeitpunkt t = 5, 1 Lymphozyte erkennt ein Dritte verdächtige Eingabe Paket und ein simulierter Alarm ausgelöst wird.

In den folgenden Abschnitten, erkläre ich zunächst die wichtigsten Konzepte des menschlichen Immunsystems, die verwendet werden, um einem AIS zu modellieren.Dann werde ich Sie durch den Code gehen, die im Screenshot in produziert Abbildung 1.Abschließend werde ich geben Ihnen einige zusätzliche Hinweise und ein paar Meinungen über AIS.Dieser Artikel setzt voraus, dass Sie mindestens Zwischenebene mit einer modernen Programmiersprache Programmierkenntnisse.Ich benutze c# für das Demoprogramm, aber ich werde erklären, in denen Sie Änderungen vornehmen müssen werde wenn Sie meinen Code in einer anderen Sprache wie Visual Basic .NET oder Python umgestalten möchten.Präsentiere ich alle den Screenshot im generierten Code Abbildung 1; der Code ist auch abrufbar unter archive.msdn.microsoft.com/mag201301TestRun.

Das menschliche Immunsystem

Die Schlüsselelemente einer stark vereinfachten Immunsystem sind abgebildet Abbildung 2.Schädliche Elemente sind Proteine, die als Antigene bezeichnet.In Abbildung 2 die Antigene sind rot gefärbt und haben scharfe Kanten.Der menschliche Körper enthält viele nicht gesundheitsschädlich Antigene, die selbst-Antigene genannt, oder self-items.Diese sind natürlich vorkommende Proteine und in Abbildung 2 sind grün gefärbt und haben Seiten gerundet.

Abbildung 2 Schlüsselelemente ein vereinfachtes Immunsystem

Antigene werden von Lymphozyten erkannt.Jede Lymphozyte hat verschiedene Antikörper, die als Melder betrachtet werden können.Jeder Antikörper ist spezifisch für ein bestimmtes Antigen.In der Regel da passender Antikörper-Antigen nur ungefähre ist, wird eine Lymphozyte Reaktion löst kein einziger Antikörper ein einziges Antigen erkennt.Erst nach mehreren ihrer entsprechenden Antigene-Antikörper wird ein Lymphozyten angeregt werden und eine Art defensive Reaktion auslösen.

Beachten Sie, dass keine Lymphozyten Antikörper, die eine self-item erkennen.Echte Antikörper entstehen durch das Immunsystem in den Thymus, aber Antikörper, die erkennen self-items zerstört werden, bevor er in die Blutbahn, einen Prozess namens Apoptose freigelassen.

Im Hinblick auf ein Intrusion Detection System entsprechen TCP/IP-Netzwerk-Netzwerkpakete, die irgendeine Art von schädlichen Daten, z. B. einen Computer-Virus, deren Inhalt enthalten Antigene.Selbst-Antigene entsprechen den normalen, nicht gesundheitsschädlich Netzwerkpakete.Ein Antikörper entspricht einem Bitmuster, die etwa ein unbekannter, potentiell schädliche Netzwerkpaket entspricht.Ein Lymphozyten repräsentiert zwei oder mehr Anti­Einrichtungen/Detektoren.Apoptosis wird mit einer Technik namens negative Auswahl modelliert.

Allgemeine Programmstruktur

Das Demoprogramm angezeigt, Abbildung 1 ist ein einzelnes c# Konsolenanwendung mit dem Namen ArtificialImmuneSystem.Ich verwendete Visual Studio 2010, aber jede Version von Visual Studio, das Microsoft .NET Framework 2.0 oder höher ist, sollte funktionieren.Ich benannte die Visual Studio generierte Vorlage-Datei mit dem Namen Program.cs zu den aussagekräftigeren ArtificialImmuneSystemProgram.cs und sowie die entsprechende Klasse umbenannt.Die gesamte Programmstruktur ist gelistet Abbildung 3.

Abbildung 3 künstliche Immunsystem Programmstruktur

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

Ich löschte alle die generierte Vorlage mit Anweisungen außer Verweise auf die Namespaces System und System.Collections.Generic. Ich habe einen Verweis auf den Namespace System.Collections, damit ich Zugriff auf das BitArray-Klasse hätte. Nach einem Start-up-Nachricht instanziiert ich ein statisches Random-Objekt unter Verwendung eines beliebigen Startwert von 1.

Vergleicht man den Code in die Main-Methode in Abbildung 3 mit dem Screenshot in Abbildung 1, Sie sollten nicht zu viel Schwierigkeiten zu verstehen, die Programmlogik. Der Schlüssel für die AIS-Demo ist die Definition der Klasse Lymphozyte. Beachten Sie, dass um die Größe des Demo-Codes klein zu halten und die Kerngedanken klar, ich entfernte den normalen Fehler überprüfen, dass Sie wahrscheinlich während der Experimente enthalten würde.

Der Lymphozyte-Klasse

Die Lymphozyten-Klasse verfügt über vier Datenfelder:

public BitArray antibody;  // Detector
public int[] searchTable;  // For fast detection
public int age;            // Not used; could determine death
public int stimulation;    // Controls triggering

Ich erkläre alle Felder mit öffentlichen Bereich der Einfachheit. Das Antikörper-Feld ist ein BitArray. Wenn Sie nicht mit BitArray vertraut sind, ist die Idee, die Verwendung ein normales Array von Int eine Auflistung von Bits dargestellt höchst ineffizient, ist da jeder Int 32-Bit Speicher benötigt. Ein Bit-Array kondensiert 32 Bits von Informationen in einer einzigen Int Speicher plus Mehraufwand für die Klasse. Programmiersprachen, die keine wie BitArray-Klasse benötigen Sie Low-Level Bitmanipulation mit bisschen Maskierung und Bitoperationen zu tun.

Das SearchTable-Feld ist ein Array, das von der Methode erkennt deutlich steigern Leistung verwendet wird. Das Age-Feld ist nicht in meiner Demo-Programm verwendet; viele AIS-Systeme verfolgen im Alter von einem simulierten Lymphozyten und probabilistisch abtöten und generieren neue Lymphozyten aufgrund des Alters. Feld Anregung ist, dass ein Zähler, der verfolgt, wie oft ein Lymphozyte-Objekt eine mögliche Bedrohung erkannt hat. In dieser Demo Lymphozyte Stimulierung Wert überschreitet den Wert 3, StimulationThreshold ist ein Alert ausgelöst.

Der Lymphozyte-Konstruktor ist:

public Lymphocyte(BitArray antibody)
{
  this.antibody = new BitArray(antibody);
  this.searchTable = BuildTable();
  this.age = 0;
  this.stimulation = 0;
}

Der Konstruktor akzeptiert einen einzelnen BitArray-Parameter, der ein Antigen/Detektor darstellt. Das SearchTable-Array ist eine private Hilfsmethode mit dem Namen BuildTable, die werde ich in Kürze mit instanziiert.

Einer der wichtigsten Teile von jedem AIS-System ist die Routine, die bestimmt, ob ein Antigen eine Muster erkennt. Erfordern eine genaue Übereinstimmung ist nicht möglich (und nicht imitieren echte Antigen-Verhalten). Frühe Arbeiten zur AIS verwendet eine Technik namens R-zusammenhängender Bits entsprechen, in dem sowohl ein Antigen und ein input-Muster die gleiche Anzahl von Bits haben und Erkennung tritt auf, wenn Antigen und Muster in r aufeinander folgende Bits entsprechen. Spätere Forschung ergab, dass ein besserer Erkennungsalgorithmus R-Brocken etwas passend ist. Die R-Brocken bisschen Übereinstimmung ist ähnlich wie R-zusammenhängender Bits entsprechen, außer dass der Antigen-Detektor kleiner als das Muster ist zu überprüfen und Erkennung tritt auf, wenn das Antigen ny Teilmenge des Musters entspricht. Beispielsweise wenn ein Antigen 110 ist und ein Muster 000110111 ist, erkennt das Antigen das Muster ab Index 3.

Wenn Sie über R-Stücke passend für einen Moment nachdenken, werden Sie erkennen, dass es fast das gleiche wie Substring-Funktion eine Zeichenfolge ist. Der einzige Unterschied ist, dass R-Brocken Abgleich Treffern Bit und Teilzeichenfolge Zeichen entspricht.

Im obigen Beispiel wäre ein einfacher Ansatz für R-Stücke passend das Muster beginnend am Index 0, dann am Index 1, dann 2 und so weiter zu untersuchen. Dieser Ansatz ist jedoch in den meisten Fällen sehr langsam. Es gibt mehrere anspruchsvolle Teilzeichenfolge-Algorithmen, die Vorverarbeitung die kleinere Detektor Zeichenfolge in ein Array (in der Regel eine Tabelle genannt) erstellen. Diese Tabelle Suche kann verwendet werden, fahren Sie fort, wenn ein Konflikt aufgetreten ist und die Leistung erheblich verbessern. In Situationen, wo kleinere Detektor Zeichenfolge immer wieder verwendet wird, verschiedene Muster zu überprüfen — wie AIS Einbruchserkennung — die Zeit und Speicher benötigt zum Erstellen der Tabelle Suche ist ein kleiner Preis für deutlich verbesserte Leistung bezahlen.

Die Lymphozyte erkennt Klassenmethode verwendet Teilzeichenfolge Knuth-Morris-Pratt-Algorithmus auf ein BitArray angewendet. Die erkennt-Methode akzeptiert eine input Muster wie 000110111 und gibt true, wenn das aktuelle Objekt Antigen, z. B. 110, das Muster entspricht. Der Code für die Methode erkennt wird aufgelistet Abbildung 4.

Abbildung 4 die Methode erkennt

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
}

Die Methode erkennt setzt das Vorhandensein der Tabelle suchen. Erinnern Sie, dass der Lymphozyte-Konstruktor ruft eine Hilfsmethode BuildTable der SearchTable zu schaffen. Der Code für BuildTable ist aufgeführt Abbildung 5.

Abbildung 5 die BuildTable-Methode

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;
}

Die Lymphozyten-Klasse definiert die überschriebene GetHashCode und ToString Merthods. Die GetHashCode-Methode wird verwendet, um zu verhindern, dass doppelte Objekte in Lymphozyten und ist:

public override int GetHashCode()
{
  int[] singleInt = new int[1];
  antibody.CopyTo(singleInt, 0);
  return singleInt[0];
}

Diese Implementierung wird davon ausgegangen, dass das BitArray Antikörper Feld 32 Bits oder weniger. Umgang mit doppelten Lymphozyte-Objekte ist in realistischen Situationen wo das Antikörper-Feld mehr als 32 Bits hat, nicht so einfach. Ein möglicher Ansatz wäre eine benutzerdefinierte Hash-Code-Methode definieren, die einen BigInteger-Typ zurückgibt (verfügbar im .NET Framework 4 und höher).

Verwendet in das Demoprogramm Lymphozyte ToString-Methode ist:

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;
}

Erstellen der explosiven

Sie kennen sicherlich Standard (AIS) Computer-Virus-Nachweis-Software wie Microsoft Security Essentials. Diese Systeme arbeiten durch eine lokale Datenbank mit bekannten Computer-Virus-Definitionen zu speichern. Wenn das Muster ein bekannten Virus erkannt wird, ist eine sofortige Warnung ausgelöst. Solche Antivirensysteme haben Probleme beim Umgang mit Variationen auf vorhandene Viren und nicht vollständig in den meisten Fällen mit einem völlig neuen Virus konfrontiert. AIS Einbruchserkennung arbeitet in den umgekehrten Weg beibehalten eine Reihe von Eingabemuster, die bekanntermaßen nicht gesundheitsschädlich sein und dann eine Warnung generiert, wenn eine unbekannte Muster erkannt wird. Auf diese Weise können AIS Intrusion Detection Systeme — im Prinzip mindestens —, neue Viren zu erkennen. Aber mit Falschmeldungen zu tun — das heißt, eine Warnung auf eine nicht schädlichen Eingaben Muster generiert — ist eine große Herausforderung für AIS-Systeme.

Ein richtiges AIS Intrusion Detection System würden viele Tausende von normalen Eingabemuster im Laufe von Tagen oder Wochen sammeln. Diese normalen gestecktes Muster würde entweder auf einen lokalen oder einen Server gespeichert werden. Auch würde ein richtiges AIS-System ständig aktualisieren der explosiven (und den induzierten Satz von Lymphozyten) des normalen Muster um normale Veränderungen des Netzwerkverkehrs im Laufe der Zeit zu berücksichtigen. Das Demoprogramm in diesem Artikel erstellt ein künstliches, statische self-set mit LoadSelfSet Methode:

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;
}

Die Methode akzeptiert einen Attrappe nicht verwendete DataSource-Parameter zu unterstellen, dass die explosiven Daten in einem realistischen Szenario nicht Hardcoded wäre. Der BitArray-Konstruktor nimmt etwas überraschend, einen Array von Werten Bool, wo wahr ein 1-Bit und falsch darstellt ein 0-Bit. Beachten Sie, dass ich die explosiven Daten, so generiert dass keine self-item mehr als zwei aufeinanderfolgende Nullen oder Einsen hat.

Das Demoprogramm verwendet Hilfsmethode ShowSelfSet, die Hilfsmethode BitArrayAsString aufruft, um den explosiven anzuzeigen:

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;
}

Erstellen der Lymphozyte-Reihe

Wenn Sie zurück auf die Erklärung der Funktionsweise des menschlichen Immunsystems verweisen, werden Sie feststellen, dass der Lymphozyte-Satz nur Lymphozyte Objekte enthalten soll, die keine Muster in der explosiven erkennen. CreateLymphocyteSet-Methode in aufgeführt ist Abbildung 6.

Abbildung 6 die CreateLymphocyteSet-Methode

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;
}

In der AIS-Terminologie verwendet die Methode CreateLymphocyteSet negative Auswahl. Eine zufällige Lymphozyte Objekt generiert und dann getestet, um festzustellen, ob es keine Muster in der explosiven, und auch dass erkennt die Lymphozyten nicht bereits im Ergebnis festgelegt. Dieser Ansatz ist ziemlich grob, und es gibt andere Ansätze, die effizienter sind. Ich benutze Wörterbüchern mit einem dummy Bool Wert vorhandener Lymphozyte-Objekte zu verfolgen; HashSet in das .NET Framework 4.5 und höher ist eine effizientere Alternative.

Generiert eine zufällige BitArray ein zufälliger Lymphozyte-Objekt erstellt:

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);
}

Hilfsmethode DetectsAny akzeptiert einen explosiven und ein Lymphozyten durch einen explosiven scannt und true zurückgegeben, wenn jedes Muster in den explosiven durch das Antigen in der Lymphozyten erkannt wird:

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;
}

Das Demoprogramm verwendet eine Hilfsmethode ShowLymphocyteSet um die generierten Lymphozyte-Objekte anzuzeigen:

public static void ShowLymphocyteSet(List<Lymphocyte> lymphocyteySet)
{
  for (int i = 0; i < lymphocyteySet.Count; ++i)
    Console.WriteLine(i + ": " + lymphocyteySet[i].ToString());
}

Zusammenfassung

Der Code und die Erklärungen in diesem Artikel vorgestellte sollten Sie eine solide Grundlage für praktische Experimente mit einem AIS geben. Forscher haben viele Optionen vorgeschlagen. Zum Beispiel löst das Demoprogramm in diesem Artikel eine Warnung, wenn eine einzelne Lymphozyten unbekannt Eingabemuster mehr als einige Schwelle einige Male erkennt. Die Idee dahinter ist, dass real Krankheitserreger viele Antigene ausstoßen. Eine andere Möglichkeit ist das AIS-System eine Warnung auslösen, erst nach mehreren verschiedene Lymphozyten unbekannte dasselbe Muster erkennen.

Es ist wichtig, darauf hinzuweisen, dass ein AIS soll keine einzige Lösung für Intrusion Detection werden. Vielmehr ist es, die traditionellen Antiviren-Software enthält eine mehrschichtige Abwehr gehören sollen. Darüber hinaus da Arbeit mit einem AIS noch relativ jung ist, gibt es viele unbeantwortete Fragen. Wenn Sie einige der Forschung über AIS untersuchen möchten, empfehle ich für Beiträge von Autoren S. Onlinesuche Forrest, s. Williams und U. Aickelin.

Dr. James McCaffrey* arbeitet für Volt Information Sciences Inc., wo er technische Schulungen für Softwareentwickler bei der Microsoft in Redmond, Washington Campus. Er hat an verschiedenen Microsoft-Produkten mitgearbeitet, unter anderem an Internet Explorer und MSN Search. McCaffrey ist der Autor von „.NET Test Automation Recipes“ (Apress, 2006). Er kann erreicht werden unter jammc@microsoft.com.*

Unser Dank gilt dem folgenden technischen Experten für die Durchsicht dieses Artikels: Dan Liebling