Este artículo proviene de un motor de traducción automática.
Ejecución de pruebas
Sistemas inmunes artificiales para la detección de intrusiones
Descargar el ejemplo de código
.jpg)
Un sistema inmune artificial (AIS) para detección de intrusos es un sistema de software que modela algunas partes del comportamiento del sistema inmunológico humano para proteger redes de computadoras de virus y ataques similares. La idea esencial es que el sistema inmunológico humano — que es un sistema complejo formado por linfocitos (glóbulos blancos), anticuerpos y muchos otros componentes — ha evolucionado con el tiempo para ofrecer una protección poderosa contra toxinas y otros agentes patógenos. Por lo tanto, modelar el comportamiento del sistema inmune humano puede proporcionar una arquitectura eficaz contra los ataques cibernéticos.
En este artículo se describen algunos de los principios de sistemas inmunes artificiales y presentar un programa para demostrar estos principios. Trabajo sobre la protección de AIS es todavía relativamente nuevo y, en mi opinión, no hay implementaciones comerciales son bastante listas para el prime time. El código que figura en el presente artículo no directamente le permitirá crear un sistema de intrusión de red realista, pero hay al menos cuatro razones por qué usted podría encontrar este artículo vale la pena leer. En primer lugar, el código le dará un punto de partida para la experimentación práctica con un simple sistema de AIS. En segundo lugar, los principios explicados serán superar el difícil escollo inicial a esta área y que pueda entender los trabajos de investigación sobre AIS. En tercer lugar, varias de las técnicas de programación utilizadas en este artículo, en particulares r-trozos poco juego y selección negativa, pueden ser útiles en otros escenarios de programación. Y en cuarto lugar, sólo puede encontrar la idea de modelar un sistema de software basado en el comportamiento del sistema inmunológico humano interesante en sí mismo.
La mejor forma de tener una idea de donde yo soy dirigido es a echar un vistazo a la captura de pantalla de una demo de ejecución, se muestra en la figura 1. El programa de demostración comienza creando un conjunto de seis patrones normales (patrones que se saben que no ser parte de algún ataque cibernético) que representan TCP/IP red paquetes en formato binario. Esto se llama el esto en la terminología de AIS. Por supuesto, en un sistema real de AIS, el Esto probablemente contendría decenas o cientos de miles de patrones, y cada patrón sería mucho más grande (típicamente 48-256 bits) que los 12 bits utilizados aquí. A continuación, el programa de demostración crea tres linfocitos artificiales. Cada linfocito tiene un anticuerpo simulado que tiene cuatro bits (nuevo, artificialmente pequeñas), una edad y un campo de estimulación. El campo de anticuerpo es esencialmente un detector. Como se verá en poco tiempo, los linfocitos se crean para que ninguno de ellos detecta ninguno de los patrones en el esto. Por ahora, tenga en cuenta que cada linfocito tiene tres ceros consecutivos o 1s, pero ninguno de los patrones en el esto tiene tres valores de bits consecutivos de igual.
.png)
Figura 1 sistema inmune Artificial Demo
Una vez inicializado el sistema, el programa de demostración comienza una pequeña simulación con seis patrones de entrada. La primera entrada se detecta por linfocitos 1, pero debido a que cada linfocito tiene un umbral de activación, los linfocitos no activan una alarma. En el tiempo t = 3, linfocitos 1 detecta otra entrada sospechosa pero, de nuevo, todavía no está sobre el umbral. Pero en el tiempo t = 5, linfocitos 1 detecta un tercer paquete de entrada sospechoso y se activa una alerta simulada.
En las secciones que siguen, primero voy a explicar los conceptos clave del sistema inmunológico humano que se utilizan para modelar un sistema AIS. Entonces te acompaño a través del código que produjo la captura de pantalla en figura 1. Concluiré dando algunas referencias adicionales y unos comentarios sobre AIS. Este artículo asume que tienes conocimientos de programación de nivel intermedio por lo menos con un lenguaje de programación moderno. Usar C# para el programa de demostración, pero voy a explicar donde tendrá que hace cambios si desea refactorizar código en otro lenguaje como Visual Basic .NET o Python. Presento todo el código que genera la captura de pantalla en figura 1; el código también está disponible en archive.msdn.microsoft.com/mag201301TestRun.
El sistema inmunológico humano
Los elementos clave de un sistema inmune muy simplificado se ilustran en la figura 2. Elementos peligrosos son proteínas llamadas antígenos. En figura 2 los antígenos son de color rojo y tienen las esquinas afiladas. El cuerpo humano también contiene muchos antígenos inocuos llamadas antígenos de uno mismo, o self-items. Estos son naturales las proteínas y en figura 2 son de color verde y lados se han redondeado.
.png)
Figura 2 elementos clave de un sistema inmune simplificado
Antígenos son detectados por los linfocitos. Cada linfocito tiene varios anticuerpos, que pueden considerarse como detectores. Cada anticuerpo es específico para un antígeno en particular. Normalmente, porque la coincidencia de antígeno-anticuerpo es sólo aproximada, linfocitos no desencadenará una reacción cuando un anticuerpo solo detecta un antígeno único. Sólo después de varios anticuerpos detectan sus antígenos correspondientes serán linfocitos ser estimulada y desencadenar a algún tipo de reacción defensiva.
Observe que no hay linfocitos tiene anticuerpos que detectan un self-item. Reales anticuerpos generados por el sistema inmune en el timo, pero los anticuerpos que detectan self-items son destruidos antes de ser liberado en el torrente sanguíneo, un proceso llamado apoptosis.
En términos de un sistema de detección de intrusos, antígenos corresponden a paquetes de red TCP/IP cuyo contenido contiene a algún tipo de datos dañinos, como un virus informático. Self-antígenos corresponden a paquetes de red normal, no perjudicial. Un anticuerpo corresponde a un patrón de bits que coincide aproximadamente con un paquete de red desconocida, potencialmente dañinos. Linfocitos representa dos o más anti/detectores de cuerpos. Apoptosis es modelado usando una técnica llamada selección negativa.
Estructura general del programa
El programa de demostración se muestra en la figura 1 es una única aplicación de C# consola con el nombre ArtificialImmuneSystem. Usé Visual Studio 2010, pero debería funcionar cualquier versión de Visual Studio que tiene Microsoft .NET Framework 2.0 o posterior. He renombrado el archivo de plantilla que genera Visual Studio llamado Program.cs a la ArtificialImmuneSystemProgram.cs más descriptivo y había renombrado de la clase correspondiente, así. La estructura general del programa aparece en figura 3.
Figura 3 estructura de programa de sistema inmune Artificial
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
Borré todo la plantilla generada usando declaraciones excepto las referencias a los espacios de nombres del sistema y System.Collections.Generic. He añadido una referencia al espacio de nombres System.Collections así que pude tener acceso a la clase BitArray. Después de un mensaje de puesta en marcha, crea una instancia de un objeto estático de Random utilizando un valor arbitrario de semilla de 1.
Si se compara el código en el método Main en figura 3 con la captura de pantalla en figura 1, no tiene demasiado problemas para entender la lógica de programación. La clave para la demostración de AIS es la definición de la clase de linfocitos. Tenga en cuenta que para mantener el tamaño del Código demo pequeño y claro las ideas clave, quité todas la normal comprobación de errores que se incluiría probablemente durante la experimentación.
La clase de linfocitos
La clase de linfocitos tiene cuatro campos de datos:
public BitArray antibody; // Detector
public int[] searchTable; // For fast detection
public int age; // Not used; could determine death
public int stimulation; // Controls triggering
Declaro que todos los campos con el ámbito público por razones de simplicidad. El campo de anticuerpos es un BitArray. Si no está familiarizado con BitArray, la idea es que utilizando una matriz normal de int para representar un conjunto de bits es altamente ineficiente porque cada int requiere 32 bits de almacenamiento. Una matriz de bits condensa 32 bits de información en un único int de almacenamiento, además de algunos gastos fijos de la clase. Lenguajes de programación que no tienen una clase BitArray como requieren manipulación de bits de bajo nivel con máscaras de bits y las operaciones de bit.
El campo searchTable es una matriz que se utiliza el método detecta para aumentar considerablemente el rendimiento. El campo de la edad no es utilizado en mi programa de demostración; muchos sistemas AIS seguimiento la edad de linfocitos simulado y probabilísticamente matan y generan nuevos linfocitos basados en la edad. El campo de la estimulación es un contador que realiza un seguimiento de cuántas veces un objeto de linfocitos ha detectado una posible amenaza. En esta demostración, cuando un valor de estimulación de linfocitos supera el valor de stimulationThreshold de 3, se activará una alerta.
El constructor de linfocitos es:
public Lymphocyte(BitArray antibody)
{
this.antibody = new BitArray(antibody);
this.searchTable = BuildTable();
this.age = 0;
this.stimulation = 0;
}
El constructor acepta un solo parámetro BitArray que representa un detector de antígeno. La matriz de searchTable se crea una instancia mediante un método auxiliar privado llamado BuildTable, que te presento poco.
Una de las partes fundamentales de cualquier sistema de AIS es la rutina que determina si un antígeno detecta un patrón. Que requiere a una coincidencia exacta no es factible (y no imitar el comportamiento real de antígeno). Los primeros trabajos sobre AIS utilizan una técnica llamada r-contiguos bits coincidentes, en el que un antígeno y un patrón de entrada tienen el mismo número de bits y detección se produce al antígeno y patrón coinciden en bits consecutivos de r. Investigaciones posteriores indicaron que un mejor algoritmo de detección es r-trozos de bits coincidentes. La coincidencia de bit r-trozos es similar a bits contiguos r juego salvo que el detector de antígeno es más pequeño que el patrón para comprobar y detección se produce cuando el antígeno coincida con el subconjunto de ny del patrón. Por ejemplo, si un antígeno es 110 y un patrón es 000110111, el antígeno detecta el patrón comenzando en el índice 3.
Si se piensa en r-trozos que por un momento, se dará cuenta de que es casi lo mismo que una función de subcadena de la cadena. La única diferencia es que r-trozos juego partidos bits y subcadena coincide con caracteres.
En el ejemplo anterior, un enfoque simple para r-trozos coincidencia sería examinar el patrón comenzando en el índice 0, luego en el índice 1, luego 2 y así sucesivamente. Sin embargo, este enfoque es muy lento en la mayoría de las situaciones. Existen varios algoritmos sofisticados subcadena que preprocesar la cadena detector más pequeña para crear una matriz (generalmente denominada tabla). Esta tabla de búsqueda puede utilizarse para saltar hacia adelante cuando se produce un desequilibrio y mejorar considerablemente el rendimiento. En situaciones donde la pequeña cadena de detector repetidamente se utiliza para comprobar diversos patrones — como en la detección de intrusiones de AIS — el tiempo y la memoria necesaria para crear la tabla de búsqueda es un pequeño precio a pagar para mejorar considerablemente el rendimiento.
El método de linfocitos clase detecta utiliza el algoritmo de la subcadena de Knuth-Morris-Pratt aplicado a un BitArray. El método detecta acepta un patrón de entrada como 000110111 y devuelve true si el antígeno del objeto actual, como 110, coincide con el patrón. El código para el método detecta cotiza en figura 4.
Figura 4 la detecta el método
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
}
El método detecta supone la existencia de la tabla de búsqueda. Recordar que el constructor de linfocitos llama a un método auxiliar BuildTable para crear el campo searchTable. Encuentra el código para BuildTable en figura 5.
Figura 5 el método de 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 clase de linfocitos define reemplazado merthods GetHashCode y ToString. El método GetHashCode se utiliza para evitar que objetos duplicados de linfocitos y es:
public override int GetHashCode()
{
int[] singleInt = new int[1];
antibody.CopyTo(singleInt, 0);
return singleInt[0];
}
Esta implementación se supone que el campo de anticuerpo BitArray tiene 32 bits o menos. En situaciones reales en el campo de anticuerpo tiene más de 32 bits, no es tan sencillo que trata con objetos duplicados de linfocitos. Un enfoque sería definir un método de código hash personalizada que devuelve un tipo BigInteger (disponible en el .NET Framework 4 y posteriores).
El método ToString de linfocitos en el programa de demostración es:
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;
}
Crear el esto
Ciertamente familiarizado con estándar (no-AIS) software de detección de virus informáticos como Microsoft Security Essentials. Estos sistemas funcionan mediante el almacenamiento de una base de datos local de definiciones de virus informáticos conocidos. Cuando se detecta un patrón de virus conocidos, se activa una alerta inmediata. Estos sistemas antivirus tengan problemas para lidiar con las variaciones de virus existentes y no totalmente en la mayoría de las situaciones cuando se enfrentan con un virus completamente nuevo. Detección de intrusiones de AIS funciona en sentido inverso, manteniendo un conjunto de patrones de entrada que se sabe que son inocuos y luego desencadenar una alerta cuando se detecta un patrón desconocido. Esto permite que los sistemas de detección de intrusos AIS — en principio, al menos — para detectar nuevos virus. Sin embargo, tratando con falsos positivos — es decir, desencadenar una alerta sobre un patrón de entrada no perjudicial — es un reto para los sistemas AIS.
Un sistema de detección de intrusiones de AIS real recaudaría miles de patrones de entrada normales en el transcurso de días o semanas. Estos patrones esto normales se almacenaría en un host local o un servidor. También, un sistema AIS real sería actualizar continuamente el esto (y el conjunto inducido de linfocitos) de patrones normales para tener en cuenta los cambios normales en el tráfico de red con el tiempo. El programa de demostración en este artículo crea un artificial, estática uno utilizando el método 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;
}
El método acepta un parámetro dummy dataSource no utilizado para sugerir que en un escenario realista los datos esto no sería codificado. El constructor BitArray, sorprendentemente, acepta una matriz de valores bool donde true representa un bit 1 y falso representa un bit 0. Observar que me generaba los datos esto de tal manera que no self-item tiene más de dos ceros consecutivos o 1s.
El programa de demostración utiliza el método de utilidad ShowSelfSet, que se llama el método auxiliar BitArrayAsString, para mostrar la esto:
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;
}
Crear el conjunto de linfocitos
Si se hace referencia a la explicación de cómo funciona el sistema inmunológico humano, te tenga en cuenta que el conjunto de linfocitos debe contener sólo los objetos de linfocitos que no detectan ningún patrón en el esto. Método CreateLymphocyteSet cotiza en figura 6.
Figura 6 el método de 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;
}
En la terminología de la AIS, el método CreateLymphocyteSet utiliza selección negativa. Linfocitos aleatorio objeto es generado y probado, a continuación, para ver si no detecta ningún patrón en el esto y también los linfocitos no ya está en el resultado conjunto. Este enfoque es bastante crudo, y hay otros enfoques que son más eficientes. Utilizar una colección de diccionario con un valor bool dummy para rastrear objetos existentes de linfocitos; HashSet en el .NET Framework 4.5 y versiones posteriores es una alternativa más eficiente.
Se crea un objeto de linfocitos al azar generando un BitArray aleatorio:
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);
}
Método auxiliar DetectsAny acepta un esto, y linfocitos explora un esto y devuelve true si cualquier patrón en el esto es detectado por el antígeno de los linfocitos:
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;
}
El programa de demostración utiliza un método de utilidad ShowLymphocyteSet para mostrar los objetos generados de linfocitos:
public static void ShowLymphocyteSet(List<Lymphocyte> lymphocyteySet)
{
for (int i = 0; i < lymphocyteySet.Count; ++i)
Console.WriteLine(i + ": " + lymphocyteySet[i].ToString());
}
En resumen
El código y las explicaciones que he presentado en este artículo deben darle una base sólida para la experimentación práctica con un sistema AIS. Los investigadores han sugerido muchas opciones. Por ejemplo, el programa de demostración en este artículo activa una alerta cuando linfocitos solo detecta patrones de entrada desconocidos más de cierto número de umbral de los tiempos. La idea es que los patógenos reales emiten muchos antígenos. Otra posibilidad es para que el sistema AIS activar una alerta sólo después de que varios diferentes linfocitos detectan el mismo patrón desconocido.
Es importante señalar que un sistema AIS no pretende ser una solución única para la detección de intrusiones. Por el contrario, ha significado para ser parte de una defensa de múltiples capas que incluye software antivirus tradicional. Además, porque el trabajo con un sistema AIS es todavía relativamente joven, hay muchas preguntas sin responder. Si desea examinar algunas de las investigaciones de AIS, te recomiendo buscar en línea de artículos de autores S. Forrest, P. Williams y U. Aickelin.
Dr.James McCaffrey trabaja para voltios Information Sciences Inc., donde dirige la formación técnica para ingenieros de software trabajando en el Microsoft Redmond, Wash.,campus. Ha trabajado en varios productos de Microsoft Internet Explorer y MSN Search. McCaffrey es el autor de ".NET Test Automation Recipes" (Apress, 2006). Él puede ser contactado en jammc@microsoft.com.
Gracias a los siguientes expertos técnicos por su ayuda en la revisión de este artículo: Dan Liebling