So erstellen Sie eine Antiviren-Engine

So erstellen Sie eine Antiviren-Engine

Einführung

Wenn ich durch die Techies-Foren streife, sehe ich oft einige Leute (und viele nicht sehr erfahrene), die nach „Wie mache ich ein Antivirenprogramm“ fragen, manchmal mit nicht sehr angepassten Sprachen (bat, PHP, …) und eine falsche Vorstellung davon haben, was ein Antivirenprogramm ist und wie es aufgebaut werden sollte.

Ich habe auch viele „Antivirus-Software“ von Kiddies gesehen, mit sehr wenigen Noch-in-der-Schule-Leuten und ungefähr 4 Stunden pro Tag der Codierung auf mehreren Wochen. Ich sage nicht, dass Kinder nicht qualifiziert sind, aber ich sage, dass der Aufbau einer Antiviren-Engine entweder viele qualifizierte Leute mit Vollzeitjob plus viel Zeit benötigt, um eine anständige Software zu veröffentlichen, oder viel Geld, um sie zu bezahlen 🙂 (falls sie nicht freiwillig sind).

Also werde ich hier die Richtlinien für eine grundlegende Antivirus-Codierung für Windows und in C / C ++ behandeln. Man kann hier die Hinweise finden, um eine Antivirus-Engine zu entwerfen, oder einfach lernen, wie die meisten von ihnen gebaut werden.

Schutz

Für einen guten Schutz muss ein Antivirenprogramm mindestens einen Treiber haben, um Code im Kernel ausführen zu können und insgesamt Zugriff auf Kernel-APIs zu haben. Beginnend mit Vista verstand Microsoft, dass die Antivirenindustrie Schlüssel benötigte, um in den Kernel einzutreten und Filter an strategischen Stellen wie Dateisystem, Registrierung und Netzwerk zu aktivieren. Seien Sie nicht fassungslos, wenn das Erstellen eines Antivirenprogramms für Systeme vor Vista ein echter Schmerz sein kann, da es nicht dafür entwickelt wurde.

• Auf Systemen vor Vista verwendeten Antivirenfirmen jedoch Rootkit-ähnliche Funktionen, um die Türen zu schützen (auch wenn dies von Microsoft überhaupt nicht empfohlen wurde) und Ihr System schützen zu können. Sie verwendeten sogenannte „Hooks“ (API-Umwege zum Filtern).
• Unter Vista + hat Microsoft APIs bereitgestellt, um unseren Low-Level-Treiber zwischen Userland-Aufrufen und Kernel-APIs einzufügen. Auf diese Weise ist es einfach, ein Antivirenprodukt im Kernel zu registrieren. Mehr, diese Art Registrierung basiertes System ermöglicht es uns, unsere Systemsicherheit in Schichten zu versenden, wo mehrere Produkte mit unterschiedlichen Zielen können zusammenleben. Dies war bei Hooks nicht der Fall, da die Implementierung vollständig produktabhängig war.

HINWEIS: Ich werde die Problemumgehungen nicht mit Hooks für Systeme vor Vista behandeln , da sie im Internet leicht zu finden sind und ein ganzes Kapitel erforderlich wäre, um zu erklären, wie, wo und so weiter gehakt wird … Aber Sie müssen wissen, dass es die gleiche Idee ist wie die Kernel-APIs, außer dass Sie selbst implementieren müssen, was Microsoft auf Vista + -Systemen bereitgestellt hat.

Um mehr über das Codieren von Treibern zu erfahren, können Sie diese nützlichen Links überprüfen:
http://msdn.microsoft.com/en-us/library/windows/hardware/gg490655.aspx
http://www.codeproject.com/Articles/9504/Driver-Development-Part-1-Introduction-to-Drivers

Um mehr über Hooks zu erfahren, können Sie dieses grundlegende Beispiel überprüfen:
http://www.unknowncheats.me/forum/c-and-c/59147-writing-drivers-perform-kernel-level-ssdt-hooking.html

Prozess

Das erste, was den Benutzer zu schützen, ist das Starten von bösartigen Prozessen. Dies ist die grundlegende Sache. Sie sollten einen PsSetCreateProcessNotifyRoutineEx-Rückruf registrieren. Auf diese Weise wird bei jeder Prozesserstellung und bevor der Hauptthread ausgeführt wird (und schädliche Dinge verursacht), der Antiviren-Rückruf benachrichtigt und erhält alle erforderlichen Informationen.

Es empfängt den Prozessnamen, das Dateiobjekt, die PID usw. Da der Prozess aussteht, kann der Treiber seinen Dienst anweisen, den Speicher des Prozesses auf böswillige Vorgänge zu analysieren. Wenn etwas gefunden wird, setzt der Treiber CreationStatus einfach auf FALSE und kehrt zurück.

NTSTATUS PsSetCreateProcessNotifyRoutineEx( _In_ PCREATE_PROCESS_NOTIFY_ROUTINE_EX NotifyRoutine, _In_ BOOLEAN Remove);

VOID CreateProcessNotifyEx( _Inout_ PEPROCESS Process, _In_ HANDLE ProcessId, _In_opt_ PPS_CREATE_NOTIFY_INFO CreateInfo);

typedef struct _PS_CREATE_NOTIFY_INFO { SIZE_T Size; union { ULONG Flags; struct { ULONG FileOpenNameAvailable :1; ULONG Reserved :31; }; }; HANDLE ParentProcessId; CLIENT_ID CreatingThreadId; struct _FILE_OBJECT *FileObject; PCUNICODE_STRING ImageFileName; PCUNICODE_STRING CommandLine; NTSTATUS CreationStatus;} PS_CREATE_NOTIFY_INFO, *PPS_CREATE_NOTIFY_INFO;

Threads

In der gleichen Idee wie für Prozesse können Threads eine Möglichkeit für böswillige Dinge sein, Schäden zu verursachen. Zum Beispiel kann man Code in einen legitimen Prozess einfügen und einen Remote-Thread für diesen Code im Kontext des Prozesses starten (einfach zu folgen? 🙂 ). Auf diese Weise kann ein legitimer Prozess böswillige Dinge tun.

Wir können neue Threads mit dem PsSetCreateThreadNotifyRoutine Callback filtern. Jedes Mal, wenn ein Thread erstellt wird, wird das Antivirenprogramm mit der TID und der PID benachrichtigt. So ist es in der Lage, in den Startadresscode des Threads zu schauen, ihn zu analysieren und entweder den Thread zu stoppen oder ihn fortzusetzen.

NTSTATUS PsSetCreateThreadNotifyRoutine( _In_ PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine);

VOID(*PCREATE_THREAD_NOTIFY_ROUTINE) ( IN HANDLE ProcessId, IN HANDLE ThreadId, IN BOOLEAN Create );

Images

Die dritte dynamische Bedrohung betrifft Bilder, die in den Speicher geladen werden können. Ein Image ist eine PE-Datei, entweder eine EXE-, eine DLL- oder eine SYS-Datei. Um über geladene Bilder informiert zu werden, registrieren Sie einfach PsSetLoadImageNotifyRoutine. Mit diesem Rückruf können wir benachrichtigt werden, wenn das Image in den virtuellen Speicher geladen wird, auch wenn es nie ausgeführt wird. Wir können dann erkennen, wenn ein Prozess versucht, eine DLL zu laden, einen Treiber zu laden oder einen neuen Prozess auszulösen.

Der Rückruf erhält Informationen über den vollständigen Bildpfad (nützlich für die statische Analyse) und die meiner Meinung nach wichtigere Bildbasisadresse (für die In-Memory-Analyse). Wenn das Image bösartig ist, kann das Antivirenprogramm kleine Tricks verwenden, um die Ausführung zu vermeiden, z. B. das Parsen des In-Memory-Images und das Aufrufen des Einstiegspunkts.

NTSTATUS PsSetLoadImageNotifyRoutine( _In_ PLOAD_IMAGE_NOTIFY_ROUTINE NotifyRoutine);

VOID (*PLOAD_IMAGE_NOTIFY_ROUTINE)( __in_opt PUNICODE_STRING FullImageName, __in HANDLE ProcessId, __in PIMAGE_INFO ImageInfo );

typedef struct _IMAGE_INFO { union { ULONG Properties; struct { ULONG ImageAddressingMode : 8; //code addressing mode ULONG SystemModeImage : 1; //system mode image ULONG ImageMappedToAllPids : 1; //mapped in all processes ULONG Reserved : 22; }; }; PVOID ImageBase; ULONG ImageSelector; ULONG ImageSize; ULONG ImageSectionNumber;} IMAGE_INFO, *PIMAGE_INFO;

Dateisystem

Sobald alle dynamischen Dinge gesichert sind, sollte ein Antivirenprogramm in der Lage sein, den Benutzer im laufenden Betrieb über schädliche Dinge zu informieren, nicht nur, wenn sie gerade gestartet werden. Ein Antivirenprogramm sollte in der Lage sein, Dateien zu scannen, wenn der Benutzer einen Ordner, ein Archiv öffnet oder wenn es auf die Festplatte heruntergeladen wird. Darüber hinaus sollte ein Antivirenprogramm in der Lage sein, sich selbst zu schützen, indem es jedem Programm verbietet, seine Dateien zu löschen.

Die Möglichkeit, all dies zu tun, besteht darin, einen Treiber im Dateisystem zu installieren, insbesondere einen Minifilter eines Legacy-Filters (alte Methode). Hier werden wir über Minifilter sprechen.

Ein Minifilter ist eine spezielle Art von Treiber, der Rückrufe bei jeder Lese- / Schreiboperation im Dateisystem registrieren kann (IRP-Hauptfunktionen). Ein IRP (Interrupt Request Paquet) ist ein Objekt, das verwendet wird, um eine Lese- / Schreiboperation auf der Festplatte zu beschreiben, die zusammen mit dem Treiberstapel übertragen wird. Der Minifilter wird einfach in diesen Stapel eingefügt und erhält diesen IRP, um zu entscheiden, was damit zu tun ist (Vorgang zulassen / verweigern).

Für ein kleines beispiel von minifilter, überprüfen sie bitte, dass nützliche link oder, dass ein. Die Microsoft-Richtlinien finden Sie hier.

Hier und hier finden Sie auch 2 Beispiele der WDK-Dokumentation.

Ein grundlegender Minifilter-Rückruf sieht folgendermaßen aus. Es gibt 2 Arten von Rückrufen, Pre-Operation und Post-Operation, die vor und nach der Abfrage filtern können. Hier ist ein Pseudocode vor der Operation:

FLT_PREOP_CALLBACK_STATUS PreOperationCallback (__inout PFLT_CALLBACK_DATA Data, __in PCFLT_RELATED_OBJECTS FltObjects, __deref_out_opt PVOID *CompletionContext){ ... if ( all_good ) { return FLT_PREOP_SUCCESS_NO_CALLBACK; } else { // Access denied Data->IoStatus.Information = 0; Data->IoStatus.Status = STATUS_ACCESS_DENIED; return FLT_PREOP_COMPLETE; } }

Registrierung

Die Registrierung ist einer der kritischsten Orte zum Schutz. Es gibt viele, viele Möglichkeiten für eine Malware persistent Hand auf dem System zu halten, indem sie eine einzelne Registrierung (oder wenige) Schlüssel / Werte in die Registrierung. Die bekanntesten Orte sind Run Keys und Services. Dies ist auch der Ort, an dem das Antivirenprogramm (zusammen mit dem Dateisystem) besiegt werden kann, indem einfach die Treiber- / Serviceschlüssel entfernt werden, sodass es beim Systemstart nicht mehr neu gestartet wird.

Dies ist keine wirkliche Notwendigkeit für ein Antivirenprogramm, um Neustartplätze zu schützen, die meisten von ihnen nicht. Aber sie müssen ihre Installationsregistrierungsschlüssel schützen, um zu vermeiden, dass sie leicht von Malware besiegt werden. Dies kann durch Registrierung von CmRegisterCallback erfolgen.

Der Rückruf liefert genügend Informationen, um den vollständigen Schlüsselnamen, die Art des Zugriffs (Erstellen, Umbenennen, Löschen, …) und die Anrufer-PID abzurufen. Auf diese Weise ist es einfach, Zugriff auf den Anruf zu gewähren oder nicht, indem Sie das Statusfeld des Rückrufs nach der Operation festlegen.

NTSTATUS CmRegisterCallbackEx(_In_ PEX_CALLBACK_FUNCTION Function,_In_ PCUNICODE_STRING Altitude,_In_ PVOID Driver,_In_opt_ PVOID Context,_Out_ PLARGE_INTEGER Cookie,_Reserved_ PVOID Reserved);

EX_CALLBACK_FUNCTION RegistryCallback;NTSTATUS RegistryCallback( _In_ PVOID CallbackContext, _In_opt_ PVOID Argument1, _In_opt_ PVOID Argument2){ ... }Argument1 = typedef enum _REG_NOTIFY_CLASS { RegNtDeleteKey, RegNtPreDeleteKey = RegNtDeleteKey,...Argument2 = typedef struct _REG_POST_OPERATION_INFORMATION { PVOID Object; NTSTATUS Status; PVOID PreInformation; NTSTATUS ReturnStatus; PVOID CallContext; PVOID ObjectContext; PVOID Reserved;} REG_POST_OPERATION_INFORMATION, *PREG_POST_OPERATION_INFORMATION;

Netzwerk (Firewall)

Um die Türen des gesamten Internetverkehrs zu schützen, der auf bestimmten Systemen (Servern, Benutzern mit großer Bandbreite) sehr groß sein kann, ohne durch die Kontextwechsel im Benutzerland verlangsamt zu werden, ist es absolut nicht empfehlenswert, eine Firewall zu installieren, die keinen zugrunde liegenden Treiber hat, mit Ausnahme einiger Webbrowser-Filter, die für http-Verkehr ausreichen können, aber nicht vor Malware-Kommunikation in / out schützen.

Um eine korrekte Implementierung der Firewall zu haben, sollte man einen NDIS, TDI oder eine andere Methode für Low-Level-IP-Filtertreiber codieren. NDIS / TDI ist etwas schwierig und würde viel Wissen erfordern (meiner Meinung nach mehr als andere Filter).

Wie auch immer, hier sind einige Hinweise, um mit der Codierung eines solchen Treibers zu beginnen, die Microsoft-Richtlinien und das alte Codeproject-Tutorial (aber immer noch gut zu lesen), ein Beispiel für die NDIS-Firewall und ein Beispiel für die TDI-Firewall. Hier ist auch ein gutes Schreiben über NDIS Firewall Bypass Trick, und eine kleine Erklärung über den Netzwerktreiber-Stack,

Userland protection

Der Userland-Schutz ist keine Notwendigkeit, kann aber ein zusätzliches Modul gegen Trojaner-Banker und insbesondere gegen Prozess-Spione sein. Sie werden im Allgemeinen aus mehreren Gründen in jeden Prozess injiziert.

Erstens können sie (bei Bedarf) den Prozess beenden, wenn er als Malware identifiziert wurde (dies sollte nicht passieren, da AVs ihn stoppen sollen, bevor er startet). Es ist immer einfacher, einen Prozess zu stoppen, wenn Sie sich in seinem Kontext befinden.

Zweitens sind sie in der Lage, kritische Prozesse wie Webbrowser vor dem Anschließen von Malware zu schützen, die API-Aufrufe umleiten und filtern kann, um Kennwörter und Bankinformationen zu sammeln und den Internetfluss an Malware-Server umzuleiten. Sie achten nur auf IAT-Modifikationen, auf Spleißen und können auch selbst Hooks setzen, um LoadLibray einer Malware-DLL zu vermeiden und somit bestimmte Methoden der Code-Injektion zu verbieten.

Eine einfache Möglichkeit, eine Protector-DLL in alle Prozesse einzufügen, besteht darin, den AppInitDll-Registrierungsschlüssel zum Registrieren der Protector-DLL zu verwenden. Es wird die DLL in jeden Prozess laden, der auf dem System gestartet wird, sobald sie den User32 verknüpfen.dll Bild (die meisten von ihnen tun).

Analyse-Engine

Die Analyse-Engine ist einer der wichtigsten Teile, sie ist verantwortlich für die Analyse von Datei- / Speicherproben, die von den Treibern stammen. If muss schnell sein (auch mit einer riesigen Datenbank) und sollte in der Lage sein, die meisten Dateitypen zu verarbeiten (Selbst extrahierte ausführbare Dateien, Archive – RAR, ZIP, gepackte Dateien – UPX, …) und sollte daher viele Module haben, um dies zu tun:

• Unpacker : Dieses Modul muss in der Lage sein, die meisten bekannten Packer (UPX, Armadillo, ASPack, …)zu erkennen und zu entpacken
• Signatur-Engine: Die Datenbank eines Antivirenprogramms enthält Millionen von Signaturen, und die Engine sollte in der Lage sein, sie schnell in einer Probe zu suchen. Daher sollte ein sehr leistungsfähiger Algorithmus Teil davon sein. Einige Beispiele : Ahmasick, RabinKarp, String-Matching-Algorithmen.
• Sandbox : Dieses Modul ist nicht notwendig, wäre aber ein Plus, um Samples in einem begrenzten Speicher ausführen zu können, ohne Auswirkungen auf das System. Dies könnte helfen, mit unbekannten Packern gepackte Samples zu entpacken und der Heuristik-Engine (siehe unten) zu helfen, API-Aufrufe zu erkennen, die als verdächtig oder bösartig angesehen werden könnten. Einige gute Sandbox hier.
• Heuristik-Engine: Wie oben erwähnt, sucht die Heuristik-Engine nicht nach Signaturen, sondern nach verdächtigem Verhalten (dh. beispiel, das eine Verbindung auf der Website öffnet hxxp://malware_besite.com). Dies kann durch statische Analyse oder über eine Sandbox erfolgen.

Signatursyntax

Die Signatursyntax ist das „Wörterbuch“ der Sprache, die die Signaturengine versteht. Es ist eine Möglichkeit zu formalisieren, welches Muster zu finden ist, wie es zu suchen ist und wo es in der Probe zu suchen ist. Die Syntax muss für die Forscher einfach genug sein, um sie zu verstehen, leistungsfähig genug, um jeden Anwendungsfall zu bewältigen, und leicht zu analysieren, um eine bessere Motorleistung zu erzielen.

VirusTotal hat eine gute Syntax und Engine (Yara-Projekt) entwickelt, die Open Source ist. Das sollte ein guter Zeiger sein, um Ihre eigene Syntax zu erstellen oder einfach zu verwenden. Hier ist auch ein guter Blog-Beitrag zum Erstellen von Signaturen für Antivirus.

Beispiel einer Signatur:

rule silent_banker : banker{ meta: description = "This is just an example" thread_level = 3 in_the_wild = true strings: $a = {6A 40 68 00 30 00 00 6A 14 8D 91} $b = {8D 4D B0 2B C1 83 C0 27 99 6A 4E 59 F7 F9} $c = "UVODFRYSIHLNWPEJXQZAKCBGMT" condition: $a or $b or $c}

Selbstschutz

Der Selbstschutz ist für ein Antivirenprogramm sehr wichtig, um nicht von einer Malware besiegt zu werden und den Benutzer weiterhin zu schützen. Aus diesem Grund sollte ein Antivirenprogramm in der Lage sein, seine eigene Installation zu schützen und die Persistenz beim Neustart aufrechtzuerhalten.

Es gibt mehrere Orte zum Schützen: Dateien, Registrierungsschlüssel, Prozesse / Threads, Speicher.

• Der Dateischutz ist in den Minifilter implementiert, mit bestimmten Regeln für die Dateien des Antivirenprogramms (Kein Zugriff beim Löschen, Umbenennen, Verschieben, Schreiben).
• Der Registrierungsschutz wird in den Registrierungsfilter integriert, wobei der Zugriff auf Registrierungsschlüssel des Treibers und des Dienstes verweigert wird.
• Die Treiber-Threads sind geschützt, da es unmöglich ist, das Kernelmodul zu entladen, ohne das System zum Absturz zu bringen
• Um den Dienst, der ein Userland-Prozess ist, schützen zu können, 2 Lösungen:

1. Am einfachsten wäre es, Regeln für Fehler im Service Manager hinzuzufügen und jede Fehlerregel auf „Dienst neu starten“ zu setzen. Auf diese Weise wird der Dienst neu gestartet, wenn er nicht vom Service Manager gestoppt wird. Natürlich sollte der Dienst keine Befehle akzeptieren können, bis das System nicht neu gestartet (oder gestoppt) wird.

1. Die zweite Methode, die allgemeiner ist, besteht darin, Rückrufe für Prozesshandles mit ObRegisterCallbacks .

Wenn Sie den ObjectType auf PsProcessType und die Operation auf OB_OPERATION_HANDLE_CREATE , erhalten Sie einen Rückruf vor und nach der Operation, und Sie können ACCESS_DENIED in ReturnStatus wenn das abgefragte Prozesshandle GrantedAccess die über Prozessabbruchrechte verfügen (oder Prozessschreibrechte oder alles, was zu einem Absturz / Kill führen kann), und natürlich, wenn der Prozess einer ist, den das Antivirenprogramm schützen muss (z. B. seinen Dienst).

Natürlich muss man auch das doppelte Handle und den PsThreadType schützen, um jede Beendigungsmethode zu vermeiden, die ein Handle für den Prozess oder einen Thread erfordert. Hier ist ein kleines Beispiel für die Verwendung dieses Rückrufs.

NTSTATUS ObRegisterCallbacks( _In_ POB_CALLBACK_REGISTRATION CallBackRegistration, _Out_ PVOID *RegistrationHandle);

typedef struct _OB_CALLBACK_REGISTRATION { USHORT Version; USHORT OperationRegistrationCount; UNICODE_STRING Altitude; PVOID RegistrationContext; OB_OPERATION_REGISTRATION *OperationRegistration;} OB_CALLBACK_REGISTRATION, *POB_CALLBACK_REGISTRATION;

typedef struct _OB_OPERATION_REGISTRATION { POBJECT_TYPE *ObjectType; OB_OPERATION Operations; POB_PRE_OPERATION_CALLBACK PreOperation; POB_POST_OPERATION_CALLBACK PostOperation;} OB_OPERATION_REGISTRATION, *POB_OPERATION_REGISTRATION;

VOID ObjectPostCallback( _In_ PVOID RegistrationContext, _In_ POB_POST_OPERATION_INFORMATION OperationInformation);

typedef struct _OB_POST_OPERATION_INFORMATION { OB_OPERATION Operation; union { ULONG Flags; struct { ULONG KernelHandle :1; ULONG Reserved :31; }; }; PVOID Object; POBJECT_TYPE ObjectType; PVOID CallContext; NTSTATUS ReturnStatus; POB_POST_OPERATION_PARAMETERS Parameters;} OB_POST_OPERATION_INFORMATION, *POB_POST_OPERATION_INFORMATION;

typedef union _OB_POST_OPERATION_PARAMETERS { OB_POST_CREATE_HANDLE_INFORMATION CreateHandleInformation; OB_POST_DUPLICATE_HANDLE_INFORMATION DuplicateHandleInformation;} OB_POST_OPERATION_PARAMETERS, *POB_POST_OPERATION_PARAMETERS;

typedef struct _OB_POST_CREATE_HANDLE_INFORMATION { ACCESS_MASK GrantedAccess;} OB_POST_CREATE_HANDLE_INFORMATION, *POB_POST_CREATE_HANDLE_INFORMATION;

GUI (Graphical User Interface)

Dies ist der sichtbare Teil des Eisbergs. Meiner Meinung nach einer (vielleicht der) wichtigste Teil, wenn Sie Ihr Produkt verkaufen möchten. Benutzer lieben, was schön, einfach zu bedienen und intuitiv ist. Auch wenn es nicht 100% effizient ist. Die GUI muss sexy sein.

Die GUI ist nur eine leere Shell, sie führt nur grafische Behandlungen durch und sendet / empfängt Befehle an den Kern (den Dienst). Es zeigt auch Fortschrittsbalken an, was analysiert wird, bietet Konfiguration und so … Hier ist die Avast-Benutzeroberfläche. Sexy, oder? 🙂

Architektur

Die globale Architektur könnte so aussehen:

1. GUI : Keine Administratorrechte, SCHWACH
2. Guard DLL(s): Webbrowser-Schutz, MITTEL
3. Service: Administratorrechte. Dient als Gateway zum Kernel-Code und trifft Entscheidungen zusammen mit einer Datenbank, STRONG
4. Treiber : Kernel-Filter, STRONG

Die GUI benötigt keine Administratorrechte, sie führt nur Benutzeraktionen aus und überträgt sie an den Dienst. Es zeigt auch den Produktstatus an. Mehr nicht, das ist nicht sein Ziel. Wenn die GUI beendet wird, ist dies kein Problem, da der Dienst sie neu starten kann.

Die Guard-DLLs (falls vorhanden) werden massiv in alle Prozesse injiziert und sollten in der Lage sein, nach IAT-Hooks und / oder schädlichen Threads zu suchen. Sie sollten ziemlich schwer zu entladen oder zu besiegen sein. Sie sind nicht kritisch, aber wichtig.

Der Service ist der Kern des Produkts. Es sollte unkillable sein oder zumindest in der Lage sein, sich beim Kill selbst neu zu starten. Der Dienst ist für die Kommunikation zwischen allen Modulen des Produkts verantwortlich, sendet Befehle an die Treiber, nimmt Befehle vom Benutzer entgegen und fragt die Datenbank zur Probenanalyse ab. Das ist das Gehirn.

Die Kernel-Treiber sind ebenfalls kritisch. Sie sind die Tentakel, die Informationen über alles sammeln, was auf dem System passiert, und sie zur Entscheidung an den Dienst übermitteln. Sie sind auch in der Lage, den Zugang zu bewachten Orten zu verweigern, basierend auf der Entscheidung des Dienstes.

Fazit

Eine starke, zuverlässige und stabile Antiviren-Engine zu entwickeln, ist eine komplizierte Aufgabe, die erfahrene Leute mit sehr guten Kenntnissen in der Windows-Kernelprogrammierung, Windows-Anwendungsprogrammierung, GUI-Design, Softwarearchitektur, Malware-Analyse, …

Das Erstellen stabiler Treiber ist ebenfalls eine komplizierte Aufgabe, da ein kleines Sandkorn das gesamte System zum Absturz bringen kann. Es braucht Tests, Tests und viele Tests. Wenn Ihre Engine fertig ist und funktioniert, müssen Sie nur noch Forscher einstellen, um Malware zu analysieren und Signaturen zu Ihrer Datenbank hinzuzufügen 🙂 Worauf warten Sie noch? Na los! Seiten

Verlinkungen

• http://www.symantec.com/connect/articles/building-anti-virus-engine