Linux Virenscanner

25. Januar 2004

Das ELF Dateiformat, Linux Viren, ihre Erkennung, und die Entwicklung eines Viren Scanners

Dobin Rutishauser Schartenfels 4 5430 Wettingen dobin.rutishauser@gmx.net

Institut Dr. Pfister Gulmstrasse 55 6315 Oberägeri Betreuer: Peter Kohl Abgabedatum: 03.11.2003

Inhaltsverzeichnis

1 Einführung 4

2 Schädliche Programme 4 2.1 Zeitbombem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2 Backdoors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.3 Trojaner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.4 Würmer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.5 Rootkits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.6 Viren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

3 Viren 5 3.1 Voraussetzungen für Viren . . . . . . . . . . . . . . . . . . . . . . . . . 5 3.2 Arten von Viren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 3.3 Viren Funktionalität . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 3.4 Aufruf des Virus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3.5 Verbreitung - Suche nach Opfern . . . . . . . . . . . . . . . . . . . . . 7 3.6 Infektion der Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3.7 Schadensroutine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3.8 Aufruf des ursprünglichen Programmes . . . . . . . . . . . . . . . . . . 7

4 Linux - von Natur aus sicher? 7 4.1 Windows - die Viren Brutstätte . . . . . . . . . . . . . . . . . . . . . . 8 4.2 Homogene Softwarelandschaften . . . . . . . . . . . . . . . . . . . . . . 8 4.3 Channeling Probleme - Code und Daten . . . . . . . . . . . . . . . . . 8 4.4 Features und Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 4.5 Rechtevergabe - die natürliche Virensicherung . . . . . . . . . . . . . . 9 4.6 Distributionswege . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 4.7 Tripwire und andere Host IDS . . . . . . . . . . . . . . . . . . . . . . . 10 4.8 Gründe für einen Virenscanner . . . . . . . . . . . . . . . . . . . . . . . 10

5 Theoretische Infektion 10 5.1 Ausführbare Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 5.2 Vireninfektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

6 ELF - das Format von Linux Executable Files 12 6.1 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 6.2 Aufbau - Theorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

6.2.1 ELF Header . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 6.2.2 Program Header Table . . . . . . . . . . . . . . . . . . . . . . . 13

7 Praktische Vireninfektion und Erkennung 14 7.1 Data Segment Append Virus . . . . . . . . . . . . . . . . . . . . . . . . 14 7.2 Text Segment Append Virus (aka Padding Virus) . . . . . . . . . . . . 15 7.3 .note Section Virus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 7.4 Segment Adding Virus . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 7.5 Text Section Append Virus . . . . . . . . . . . . . . . . . . . . . . . . 17 Linux Virenscanner 3

8 Der Linux Virenscanner 18 8.1 Benutzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 8.2 Desinfektion - Schadensbegrenzung oder nicht? . . . . . . . . . . . . . . 18

9 Rechtliches 18 10 Fazit 19 11 Erklärung von Begriffen 19 12 Referenzen 20 A Virus Ausführen ohne den Entry Point zu verändern 21 B sthlm - ein Data Segment Append Virus 22 C ELF C Strukturen 22

C.1 ELF Header . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 C.2 ELF Segment Header . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

1 Einführung

Hier stelle ich die Entwicklung eines Virenscanners für das Betriebsystem Linux vor. Viren sind schon seit Jahren ein Problem für Windows Systeme. Viren sind unsichtbar und erwischen früher oder später jedermann, auch wenn man noch so gut vorbereitet ist. Virenscanner bringen Licht ins Dunkel, bzw. eine Späterkennung, sobald ein Virus auf einem System Fuss gefasst hat. Warum Linux nicht im gleichen Masse betroffen ist wie Windows, wie Viren funktionieren und wie man sie erkennt sind die behandelten Themen dieser Maturaarbeit.

2 Übersicht schädlicher Programme

2.1 Zeitbombem

Zeitbomben sind kleine Programme, die versteckt an einem Ort lauern und sich nach einer gewissen Zeit oder an einem bestimmten Datum selber aktivieren, und dabei eine Schadensroutine (meistens das Löschen von Daten) ausführen. ein gekündigter Mitarbeiter kann z.B. vor seiner Entlassung noch ein Programm schreiben, dass in 5 Jahren alle Dateien auf dem Firmen Server löscht, o.ä.

2.2 Backdoors

Ein Backdoor ist eine Hintertür in einem Computer. Sobald ein Hacker mühsam in ein Computersystem eingebrochen ist, braucht er eine einfache Möglichkeit, darauf zurückzukehren, bzw. den Zugang zu behalten. Also installiert er ein kleines Programm, das es ihm z.B. erlaubt, Befehle über das Netzwerk an den Computer zu senden und eventuelle Sicherheitsmassnahmen (Firewall^{1}, Passwortabfragen, IDS^{2} etc) zu umgehen. Auch kann er nur ein Programm auf diesem System hinterlassen, das ihm später eine höhere Privilegienstufe zuweist, wenn er schon normalen User Zugang hat. Auf Windows Systemen wird meist ein Backdoor benutzt, um überhaupt Kontrolle über den Computer zu haben, da es Windows an einfachen Remote Control Funktionalität fehlt.

2.3 Trojaner

Ein Trojaner ist, wie der Name schon sagt, einem Trojanisches Pferd sehr ähnlich. Dabei handelt es sich um ein Programm, das eine Vordergründige Funktionalität hat (z.B. ein Bildschirmschoner, ein Spiel), aber auch noch eine versteckte, hintergründige, z.B. ein Backdoor installieren. Im allgemeinen Sprachgebrauch werden aber Backdoors meist Trojaner genannt. Bekannteste Beispiele sind wohl Bo2k, Subseven und Netbus.

2.4 Würmer

Würmer sind eigenständige Programme, die sich über das Netzwerk ausbreiten. Ein Wurm wird auf einem Computer (Host) gestartet, und beginnt dann an im Netzwerk (meist dem Internet) nach anderen Computern zu suchen, die einen bestimmten Service anbieten (z.B. Web Server, Datenbank Server), wobei das Programm, das diesen Service anbietet, Sicherheitslücken haben kann, bzw. für die Verbreitung des Wurms haben muss. Durch diese Sicherheitslücke kann der Wurm Code auf dem Host ausführen, und sich dadurch auf ihn weiterkopieren. Danach beginnt auf dem Host der ganze Prozess von vorne. Würmer sind den Viren noch am änlichsten, es gibt aber auch ein paar bedeutende Unterschiede. z.B. verbreiten sich Würmer, einmal losgelassen, ohne Interaktion von Menschen völlig selbstständig. Würmer müssen auch nicht möglichst klein sein, sondern fallen meistens sowieso schon durch den gewaltigen Traffic auf, den sie verursachen können^{3}. Ein Wurm beinhaltet meist auch ein Backdoor, damit die infizierten Computer anderweitig gebraucht werden können. Würmer sind zurzeit die grösste Gefahr für vernetzte Computer.

1Ein System, dass Zugriffe vom Netzwerk auf bestimmte Services einschränkt

2Ein System, das (Hacker-) Angriffe auf ein Netzwerk oder Host erkennt

2.5 Rootkits

Ein Rootkit beinhaltet eine Anzahl veränderter Kopien von normalen Systemprogrammen, welche so modifiziert wurden, dass sie Informationen vorenthalten. Zum Beispiel existiert ein Programm namens ”ls”auf Unix Systemen, welches die Dateinamen in einem Verzeichnis auflistet. Ein Rootkit hat eine eigene Version von ”ls”, welche aber so verändert wurde, dass sie bestimmte Dateien nicht anzeigt. z.B. alle Dateien im Verzeichnis ”/tmp/hacker”, in welchem der Hacker seine Dateien ablegen kann, ohne dass sie entdeckt werden.

2.6 Viren

Ein Virus ist ein kleines, selbstständiges Code Konstrukt, das sich in ausführbare Dateien hineinkopiert, um sich weiter zu verbreiten. Viren haben ziemlich viel gemeinsam mit ihren biologischen Vorbildern. Ihr einziger Zweck ist es, sich zu vermehren und zu verbreiten. Dies können sie nur, indem sie sich in andere Programme (bzw. Zellen) hineinschleusen, und sie dann zur Vermehrung missbrauchen. Den Wirt (Computer, bzw. Mensch) können sie nicht ohne weiteres Verlassen, sondern brauchen dazu externe Faktoren, die ihnen das ermöglicht (Kopieren von Dateien durch den User).

3 Viren

3.1 Voraussetzungen für Viren

Viren brauchen keine grossen Voraussetzungen um zu existieren. Gibt es in einem Computersystem ausfürbare Dateien, und Funktionen zum Kopieren von Daten, ist es auch möglich, einen Virus zu schreiben. Wichtig ist, dass die Viren irgendwann direkt oder indirekt vom User aufgerufen werden müssen. Das setzt also voraus, das sie sich irgendwo verstecken, wo der Computer Code ausführen kann. Das Ziel eines Virus ist eine möglichst grosse Verbreitung. Durch eine Entdeckung wird die Verbreitung verlangsamt, wenn nicht sogar gestoppt. Ein Virus wird also durch allerlei Massnahmen versuchen, unentdeckt zu bleiben, z.B. indem er klein ist (nicht viel Code in Anspruch nimmt), oder durch Polymorphie (dynamische Veränderung des eigenen Codes), Verschlüsselung und andere Versteckungs- und Abwehrtechniken. Auch wird ein Virus, der gezielt Schaden anrichtet (Dateien Löschen etc) oder schlampig programmiert ist, schneller entdeckt.

3Das Bedeutet, das Würmer mehr Features beinhaltet können. Insbesondere weil es üblich ist, sie in einer Hochsprache (meist C) zu schreiben

3.2 Arten von Viren

Der Virus Code muss also vom User aufgerufen werden. Was einfach tönt, ist in der Praxis nicht ganz so simpel. Auch schränkt es die Verbreitungsarten stark ein. Mögliche Haupt-Verbreitungsarten sind:

• Datei Viren Nutzen ausführbare Dateien für die Verbreitung. Dias War lange die häufigste Verbreitungsform unter Windows^{4}. Auf diese Virenart bezieht sich auch der weitere Text.

• Makro Viren Verbreiten sich mit Hilfe von Dokumenten, meistens MS Office. Dadurch, dass die heutigen Office Packete mächtige Scriptsprachen besitzen, kann man Viren nun auch in diesen Sprachen entwickeln. Ausserdem werden Dokumente mehr und selbstverständlicher getauscht, bzw. weitergereicht, so dass sich diese Viren schnell und unauffällig weiterverbreiteten können. Auch die heute so verbreiteten Mail Viren/Würmer sind im Prinzip Makro Viren, da sie die Funktion des E-Mail Programmes (zu 99,9% MS Outlook) oder Windows (Windows Scripting Host) nutzen, um sich an weitere Mail Adressen zu verschicken.

• MBR Viren Waren vor langer Zeit aktuell, als man noch mit Hilfe von Disketten bootete. Der Virus plazierte sich in den Bootsekter der Disketten, von wo er beim booten gestartet wurde und dann den Computer infizierte. Von dort infiziert er jede weitere eingelegte Diskette. Ist heute irrelevant.

3.3 Viren Funktionalität

Viren kann man in zwei funktionale Einheiten unterteilen:

• Verbreitung und Infektion

• Schadensroutine

Ersteres macht einen Virus erst zu einem Virus. Der Funktionsweg eines Virus nach seinem Start kann man in die folgenden Punkte einordnen:

• Scannen nach weiteren Zielen

• Infizieren dieser Ziele

• Aufruf der Schadensroutine

• Aufruf des ursprünglichen Programmes

4sie wurden jetzt durch Makroviren abgelöst

3.4 Aufruf des Virus

Beim Starten des Programmes muss irgendwie der Virus aufgerufen werden. Dies kann z.B. dadurch geschehen, dass sich der Virus vor das eigentliche Programm kopiert, es also aus dem Weg schiebt. Andere Möglichkeiten wären auch, den Virus beim Beenden des Programmes zu starten, oder Code im ursprünglichen Programm so zu verändern, dass der Virus aufgerufen wird.

3.5 Verbreitung - Suche nach Opfern

Bei jeder Ausführung des Virus wird zuerst nach anderen Zielen, bzw. Dateien gesucht. Wenn welche gefunden werden, werden diese infiziert. Je mehr Dateien infiziert sind, um so höher ist die Change, dass sie einmal aufgerufen werden, und umso höher ist die Infektionsrate. Spätestens aber wenn alle ausführbaren Dateien auf einem Computer infiziert sind, stoppt das Wachstum fürs erste. Zur weiteren Verbreitung muss nun eine infizierte Datei in einen anderen Computer gelangen. Dies kann der Virus nicht bewerkstelligen, sondern muss vom User erledigt werden, z.B. durch das Kopieren eines wichtigen/interessanten Programmes auf Diskette, per E-Mail o.ä, und dann das kopieren und/oder Ausführen dessen auf einem anderen Computer. Dort startet der Infektionskreislauf von vorne.

3.6 Infektion der Dateien

Ein Virus kopiert sich dorthin, wo er sicher ausgeführt wird. Also an Anfang/Ende von ausführbaren Dateien, in Makros etc. Typischerweise kopiert der Virus dafür erst die Datei, überschreibt dann ab der Position, an die er sich einfügen will das ursprüngliche Programm, und kopiert zuletzt aus der Kopie die restlichen Daten, ab der Position, ab der er angefangen hat zu überschreiben.

3.7 Schadensroutine

Die Schadensroutine (Payload) ist optional. Die Funktion kann das Löschen aller Dateien auf dem Computer an einem bestimmten Tag sein, das Darstellen eines Nag Screens, das Installieren eines Backdoors etc. Zur Schadensroutine gehört immer noch ein ”Trigger ”, der entscheidet, wann der Payload ausgefürt wird (An einem bestimmten Datum, nach N Infektionen etc). Die Schadensroutine ist wohl das Gefürchtete an Viren, ist aber in den meisten Viren gar nicht enthalten.

3.8 Aufruf des ursprünglichen Programmes

Am Ende seiner Ausfürung muss der Virus das urpsrüngliche Programm starten. D.h, er muss irgendwo Informationen gespeichert haben, wo das ursprüngliche Programm anfängt, und springt dann an diese Position.

4 Linux - von Natur aus sicher?

Linux ist ein freies Open Source Betriebsystem, das auf einer Unmenge verschiedener Computer Architekturen läuft. Es wird von tausenden Entwicklern rund um die Welt weiterentwickelt, meist ohne Entgeld. Linux ist Posix-kompatibel und UNIX-ähnlich.

4.1 Windows - die Viren Brutstätte

Ein Computer mit Windows ohne Virenscanner ist angesichts der schieren (un)menge an Viren (mehrere Zehntausende) fast schon fahrlässig. Es gibt Personen die sagen, das Linux mit steigender Popularität auch ein immer grösseres Virenproblem haben wird. Leider sind diese nicht im Besitz aller Fakten, von denen ich hier einige darlege. Ein interesanter Artikel darüber ist [16]

4.2 Homogene Softwarelandschaften

Windows Anwender benutzen zum grössten Teil die in Windows integrierte Software, wie den Internet Explorer oder Outlook (Express). Dass wohl zum einen Teil aus faulheit, sich nach besseren Alternativen umzusehen, naivität oder weil sie auf proprietäre Features angewiesen sind. Sobald ein Fehler in so einer Software gefunden wird, sind Millionen von Installationen betroffen, bzw. Ziele. Unter Linux gibt es nicht EIN Programm, das perfekt für einen Zweck geignet ist. Jeder User, der mit den derzeitigen Programmen nicht zufrieden ist, kann sich ein neues coden, dass genau auf seine Bedürfnisse zugeschnitten ist. Bekannte E-Mailprogramme sind z.B. Mutt, Pine, Mozilla Mail, Evolution, Sylpheed, Balsa (GNOME), Kmail (KDE) etc^{5}.

4.3 Channeling Probleme - Code und Daten

Wie schon gesagt besteht für die CPU der Unterschied zwischen Code und Daten nur darin, das beim ausführen ersteres kein Schrott herauskommt. Werden in einer Datei nur Daten, z.B. Text gespeichert, hat ein Virus keine Change je ausgeführt zu werden. Viele Entwickler vermischen aber Code und Daten, z.B. in Word Dokumenten, welche den eigentlichen Text beinhalten, aber auch noch Formatierungsanweisungen und sogar ausfürbare Programme (Makros) integrieren. Durch diese vermischung ergeben sich automatisch Sicherheitlöcher, und weitere Möglichkeiten für Viren. Linux Entwickler haben ein besseres Verständnis dafür, Code und Daten wenn immer möglich zu trennen. E-Mailprogramme zeigen z.B. den HTML Teil von HTML Mails erst an, wenn der User ihn explizit anklickt, evntl noch mit Sicherheitsabfragen. HTML kann ausfürbare Code beinhalten, wie Javascript.

4.4 Features und Bugs

Programmierer sind auch nur Menschen. Sie machen Fehler, und können nicht alles wissen. Ihre Programme beinhalten auch Fehler. Immer. Die Frage ist nur, wie viele und mit welchen Ausmassen. Ausserdem gibt es ein Gesetz, welches lautet, dass mehr Code automatisch auch mehr Bugs einführt. Microsoft ist ausserdem eine Aktiengesellschaft, d.h, sie muss Gewinn erwirtschaften. Dafür muss sie möglichst viel Software verkaufen. Und Software verkauft sich besser, wenn sie mehr Features hat, als wenn der Hersteller freudig verspricht, dass die neue Version viel stabiler und schneller ist.

5eine Liste gibts unter http://mahogany.sourceforge.net/clients.html

Linux aber ist kein kommerzielles Unternehmen. Es wird hauptsächlich von Programmierern weiterentwickelt, welche auf ihr Produkt oder Beitrag stolz sein wollen. Für ein Programm, dass die ganze Zeit abstürzt, bekommt er keine Anerkennung, und die will auch keiner benutzen, da es sowieso bessere Alternativen gibt. Durch Open Source sehen sich auch viele Entwickler den Source Code an, und mehr Augen sehen mehr Bugs. Durch diese Gründe wird die Qualität der Software gesteigert. Absolut Bug-Free wird sie aber dadurch auch nicht.

4.5 Rechtevergabe - die natürliche Virensicherung

Linux hat die Rechtevergabe von Unix geerbt. In Unix-kompatiblen Betriebsystemen werden die User in zwei Kategorien eingeteilt:

• Root (Super User, Systemadministrator)

• User (Normale -)

Root kann und darf alles machen, vom Löschen und Anlegen von Dateien, Installieren neuer Programme bishin zur Systemkonfiguration. Normale User dürfen nur das machen, was Root ihnen erlaubt. D.h., sie dürfen nur bestimmte Dateien ausführen, bestimmte Dateien lesen, und auf andere schreiben. Unter der Annahme, dass der User wirklich als User arbeitet, haben Viren auf Linux Systemen relativ wenig Chancen. Wenn sich ein User ein Virus einfängt, kann dieser nur die Dateien infizieren, auf die der User Schreib-Zugriff hat. Da unter diesen in der Regel ziemlich wenige ausführbare Programme sind, und sie selten von anderen Usern, oder gar von Root ausgeführt werden, ist die Verbreitungsrate des Virus extrem langsam, wenn nicht gar nichtexistent. In letzter Zeit zeigte sich aber, dass vor allem unbedarfte User, also Einsteiger oder Umsteiger, sich mit der Rechtetrennung nicht auskennen (da Windows so etwas nicht (Windows 95, 98, ME) oder nur optional (NT, 2000, XP) anbietet) und als Root arbeiten. Unterstützt wird das durch Distributionen, die den Anwender automatisch als Root einloggen (z.B. Lindows), zwecks Bequemlichkeit und Vereinfachung. Dadurch erhöht sich die Gefahr, das Linux User Opfer von Viren werden.

4.6 Distributionswege

Programme werden unter Linux in der Regel nicht als Binary verbreitet, wie unter Windows üblich, sondern als Sourcecode. Das Installationprogramm ist also das Script, das auch die Compilierung des Programmes steuert. Die Weitergabe durch den Sourcecode wird also extensiv gefördert, während sich dadurch die Weitergabe von Binarys (und damit Viren) fast verunmöglicht. Auch sind viele Programme von Usern und nicht von Firmen programmiert, sie sind meistens gratis und stehen unter der GPL^{6}. Daher werden Programme meist von zentralen Servern vom Internet heruntergeladen. Das kann die Homepage des Autors, oder es können grosse Server wie freshmeat.net sein, wo tausende solcher Programme gespeichert sind. Neuere Distributionen (Debian, Gentoo, aber auch BSD’s) haben auch eine Integrierte Packetverwaltung, d.h, um ein Programm zu installieren braucht es nur ein einfacher Befehl (z.B. ”apt-get install mozilla”, ”emerge openoffice”, ”cd /usr/ports/ftp/wget; make install”), und der Rest (downloaden des Sources, Patches, Kompilation und Installation) erledigt ein Script. Nur als Binarys vertriebene Programme (z.B. Game Server wie Q3, HL etc oder Propertionäre Programme) schränken den Anwenderkreis ein. Ein für Redhat 8.0 Linux auf Intel Compilierter UT2003 Game Server muss nicht unbedingt auf Suse Linux laufen, und schon gar nicht auf einer anderen Architektur wie Sparc, Motorola, Alpha o.a. Ausserdem werden solche Programme meistens von den Websiten der Hersteller heruntergeladen. Durch all diese Gründe werden unter Linux Binarys nur sehr selten weiterkopiert. Schlechte Aussichten also für Linux Viren.

6GNU Public License, http://www.gnu.org/licenses/gpl.html

4.7 Tripwire und andere Host IDS

Wenn ein Hacker in ein System eingedrungen ist, wird er höchstwarscheinlich ein Backdoor oder änliches installieren wollen. Meistens wird er desswegen eine Datei auf dem System verändern, neu anlegen oder löschen müssen. Sicherheitsorientierte Administratoren installieren nun Software, um solche Änderungen zu erkennen. Wenn nun eine Datei verändert wird, wird dem Admin z.B. eine Email geschickt, und wird so informiert dass etwas nicht in Ordnung ist, dass ein Angriff stattfindet (-fand), und welche Dateien verändert wurden. Die bekannteste Software dafür ist wohl Tripwire, dass MD5 Summen von Dateien in eine Datenbank speichert, und diese später regelmässig mit der neuberechneten MD5 Summe derselben Datei vergleicht. Wird bei einer Datei nur ein Bit verändert, stimmen die MD5 Summen nicht mehr überein und Tripwire schlägt Alarm. Da ein Virus auch die Datei verändern muss, erkennen solche Programme auch Viren.

Der Nachteil hier ist, dass solche IDS Systeme sehr aufwändig im Unterhalt sind, und sie nur wenige Administratoren einsetzen. Auch zeigen sie nur veränderte Dateien an, und weder, ob eine Vireninfektion stattgefunden hat, noch können sie sie identifizieren oder reparieren.

4.8 Gründe für einen Virenscanner

Je mehr Anfänger Linux benutzen, umso höher steigt die Chance, dass sich Viren verbreiten können und Linux als Viren-Platform attraktiv wird. Wenn das Viren Problem ignoriert wird, können diese sich leicht ausbreiten, ohne dass es die meisten Administratoren oder gar User bemerken. Ein Hacker kann auch den Zugriff auf ein System behalten (oder sogar erhalten), indem er ein Virus mit Backdoor in das System einschleust. Eine Säuberung wäre dann fast nicht mehr möglich. Im schlimmsten Fall würde sogar eine restauration vom Backup den Virus wieder installieren.

5 Theoretische Infektion

5.1 Ausführbare Dateien

Ein Programm ist immer in einer ausführbaren Datei auf der Festplatte gespeichert. Unter Windows wird es in .exe oder .com Files nach dem COFF Standard gespeichert, unter Linux nach dem ELF (Executable and Linkable Format) Standard.

Eine ausführbare Datei beinhaltet alle Informationen, die ein Programm zur Ausführung braucht. Unter anderem:

• Das Programm selbst (Code)

• Statische Daten des Programms (Data)

• Informationen zur Datei selbst, deren Aufbau, für das Laden des Programs etc.

Diese Informationen müssen in einer logischen und standardisierten Weise gespeichert werden, damit das Betriebsystem das Programm laden und ausführen kann. Grafisch vereinfacht dargestellt sieht solch eine Datei etwa so aus:

Beim Laden des Programmes wird der Code und die Daten in den Speicher (RAM) geladen, und dann ausgeführt. Das Ausführen des Programmes beginnt im Prinzip damit, dass auf die Adresse im Speicher gesprungen wird, wo der Code beginnt (hier also beim der Adresse 0x10).

5.2 Vireninfektion

Biologische Viren verbreiten sich, indem sie in eine Zelle eindringen und diese danach so umfunktionieren, dass sie Kopien des Virus herstellt. Ein Computer Virus arbeitet ähnlich. Er wird nach anderen ausführbaren Dateien suchen, und sich dann in diese hineinkopieren. Danach befindet sich eine komplette, ausführbare Kopie des Virus in dem Programm. Dabei ist es wichtig, das bei dessen Ausführung zuerst der Virus, und danach das eigentliche Programm gestartet wird. Nur, wenn der Virus zuerst ausgeführt wird, ist seine Ausführung gewährleistet. Damit der Virus nicht auffliegt, muss nachher auch das ursprüngliche Programm gestartet werden. Theoretisch kopiert sich ein Virus also am besten einfach seinen Code vor das eigentliche Programm:

Wenn die Datei nun ausgeführt wird, wird zuerst der Virus aufgerufen. Danach wird einfach das ursprüngliche Programm gestartet.

Praktisch ist die Infektion nicht so einfach, da durch das Einfügen von Code am Anfang der Datei alle Speicheradressen verschoben werden. Das bedeutet, dass der Computer Daten nicht mehr richtig lesen kann, eine Ausführung würde verunmöglicht.

6 ELF - das Format von Linux Executable Files

6.1 Einführung

ELF ist das Standard Format für ausführbare Dateien unter Linux und anderen Unices (Free/Net/OpenBSD, Solaris etc). ELF ist dazu da, Maschienencode so anzuordnen, dass er leicht, schnell + effizient von einem Massenspeicher in den RAM eines Computers geladen und ausgeführt werden kann. Dazu beschreibt ELF, wie die Befehle in einer Datei organisiert sind, und hat zusätliche Informationen wie sie interpretiert und geladen werden müssen. Der Hauptgrund für so ein Format ist, dass der Computer nicht zwischen ausführbaren Code und reinen Daten unterscheiden kann, für ihn sieht beides gleich aus (010111..). Damit er nicht versucht, z.B. Daten auszuführen, braucht es einen Standard, der regelt, was was ist, wo es hingehört und wie das System es zu interpretieren hat. Es gibt 3 Verschiedene ELF Typen, von denen hier aber nur einer von interesse ist: Das ”Executable File”.

6.2 Aufbau - Theorie

Wie schon weiter oben beschrieben, besteht ein Programm mindestens aus 3 Teilen; den Befehlen (Code), den Daten (Data), und weiteren Informationen zur Datei. Diese Informationen müssen irgendwie gespeichert, und später wieder ausgelesen werden. Wenn man nun diese Informationen einfach in eine Datei speichern würde, sähe das nach irgendwelchen Zufallsdaten aus. Eine Struktur muss also her. Diese stellt ELF bereit. ELF unterteilt die Datei in verschiedene Segmente, welche je gleich zu behandelnde Daten beinhalten. z.B. gibt es ladbare (loadable) und nicht ladbare Segmente, oder solche, die ausführbar und lesbar sind (RE, für Code), oder solche die lesbar und schreibbar sind (RW, für Daten). Im Header stehen Informationen zur Datei selbst. Hier beschränken wir uns auf die Adressen der Segmente in der Datei.

Nun existiert eine Struktur in der Datei, man kann auf die einzelnen Segmente zugreifen, den Code und die Daten in den Speicher laden, ihre Grösse bestimmen etc.

6.2.1 ELF Header

Der ELF Header ist immer am Anfang der Datei. Er beschreibt, wie er und der Rest der Datei aufgebaut ist, wie er interpretiert werden soll und wo sich zusätzliche Informationen zur Datei befinden. Informationen, die der ELF Header beinhaltet, sind:

• Einsprungspunkt (Entry Point)

• grösse des ELF Headers

• Adresse der Program Header Table

• Grösse der einzelnen Program Header Entrys

• Anzahl der Program Header Entrys

• u.v.m (siehe Anhang C.1 für den kompletten Header)

Hier sehen wir, dass der ELF Header die Adresse der Program Header Table angibt. Die Informationen zu den Segmenten sind also nicht im Header, sondern wurden zwecks erweiterter Flexibilität ausgelagert. Im nächsten Abschnitt gehe ich genauer auf sie ein. In diesem Text interessieren wir uns vor allem für den Einsprungspunkt. Sobald die Datei in den Speicher geladen ist, wird mit der Ausführung des Programms begonnen. Der Entry Point zeigt auf den Anfang des Code Segments, also dort, wo sozusagen das Programm (bzw. die Befehle) beginnen.

6.2.2 Program Header Table

Die Program Header Table ist eine Aneinandereihung von Program Header Entrys. Jeder Program Header Entry beschreibt ein Segment. Die Beschreibung beinhaltet:

• Segment Typ (Load, Note, Dynamic etc)

• Datei Offset

• Virtuelle Adresse (im Speicher)

• Grösse

• und mehr (siehe Anhang C.2 für den kompletten Aufbau)

Ein typisches ELF Programm unter Linux besteht aus 3 Segmenten:

• ein Read-Only Segment, vorallem für den Code

• ein Read-Write Segment, vorallem für Daten

• ein NOTE Segment, in dem der Namen des Compilers verzeichnet ist (z.B. gnugdb)

Für Neugierige, hier eine Beispielsausgabe der Segment Informationen eines Linux Binarys:

minime:~ $ readelf -l /bin/ls
Elf file type is EXEC (Executable file)
Entry point 0x8049660
There are 7 program headers, starting at offset 52
Program Headers:
  Type         Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
  PHDR         0x000034 0x08048034 0x08048034 0x000e0 0x000e0 R E 0x4
  INTERP       0x000114 0x08048114 0x08048114 0x00013 0x00013 R   0x1
      [Requesting program interpreter: /lib/ld-linux.so.2]
  LOAD         0x000000 0x08048000 0x08048000 0x11ea0 0x11ea0 R E 0x1000
  LOAD         0x012000 0x0805a000 0x0805a000 0x00338 0x006c8 RW  0x1000
  DYNAMIC      0x0120f4 0x0805a0f4 0x0805a0f4 0x000d8 0x000d8 RW  0x4
  NOTE         0x000128 0x08048128 0x08048128 0x00020 0x00020 R   0x4
  GNU_EH_FRAME 0x011d40 0x08059d40 0x08059d40 0x0004c 0x0004c R   0x4
 Section to Segment mapping:
  Segment Sections...
   00
   01     .interp
   02     .interp .note.ABI-tag .hash .dynsym .dynstr .gnu.version
          .gnu.version_r .rel.dyn .rel.plt .init .plt .text .fini
          .rodata .eh_frame_hdr .eh_frame
   03     .data .dynamic .ctors .dtors .jcr .got .bss
   04     .dynamic
   05     .note.ABI-tag
   06     .eh_frame_hdr

7 Praktische Vireninfektion und Erkennung

Hier beschreibe ich ein paar typische Infektionsmethoden von Viren und deren erkennung.

7.1 Data Segment Append Virus

Wie wir vorhin gesehen haben, zeigt der Entry Point normalerweise auf den Anfang des Code Segments.

Nun kann sich ein Virus an das Ende des Data Segmentes, oder in ein zusätzliches, evntl neu erstelles Segment kopieren. Um dann aber ausgeführt zu werden, muss der Entry Point verändert werden, damit zuerst der Virus ausgeführt wird. Nachdem der Virus seine Arbeit getan hat, wird zuletzt zum ursprünglichen Code (bzw. Programm) zurückgesprungen.

Solche Viren lassen sich ganz einfach erkennen, indem kontrolliert wird, ob der Entry Point in das Code Segment zeigt. Im Virenscanner sieht der Code zur Erkennung so aus:

   exec_prg = find_text (elfh, prgh);
   if ( elfh->e_entry < prgh[exec_prg].p_vaddr || \
        elfh->e_entry > prgh[exec_prg].p_vaddr + prgh[exec_prg].p_memsz )
   {
      printf ("KO: entry point not in text segment!\n");
   }

Die meisten der heute verfügbaren Viren lassen sich also durch diese einfache Methode erkennen. Die Data Segment Append Methode ist die effizienteste, um einen Virus (oder allgemein Code) in ein Binary einzuschleusen. Vorteile sind vorallem die Verfügbarkeit überall, und das Hinzufügen von unbegrenzt viel Code. Nachteile sind die enorme Zunahme der Dateigrösse und die leichte Entdeckbarkeit. Vor allem letzteres lässt sich aber durch eine der in Appendix A beschriebenen Techniken verhindern. Beispiels-Virus: sthlm (siehe Anhang B)

7.2 Text Segment Append Virus (aka Padding Virus)

Bei dieser Methode wird das Padding zwischen dem Code und Data Segment ausgenutzt, welches in vielen (aber nicht allen) Fällen genug Platz für einen Virus hat. Das sieht dann so aus:

Der ELF Standard gibt vor, dass die Adresse vom Data Segment Kongruent zu der von Text Segment modulo PAGE SIZE sein muss, dadurch entsteht in der Datei eine Lücke, in die man den Virus einfügen kann. Der Virus aus Silvios Text ”Unix Parasites”[10] nutzt genau diese Technik. Die Erkennung solcher Viren Typen ist auch relativ einfach. Wenn angewandt, erkennt man dadurch auch alle anderen hier beschrieben Viren. Um dieser Erkennung zu entgehen, müsste eine in Anhang A aufgefürten Stealth Mechanismen angewandt werden.

Das Text Segment besteht leider nicht, wie wir bisher zur Vereinfachung angenommen haben, nur aus dem Code, sondern beinhaltet noch andere Informationen, welche uns hier aber nicht weiter interessieren. Alle Segmente sind noch in sogenannte Sections unterteilt, wobei die .text Section wohl am wichtigsten ist. Sie beinhaltet wirklich nur den Code des auszuführenden Programmes. Wenn der Entry Point nicht in diese Section (bzw. genau an den Start) zeigt, war wohl ein Virus am Werk.

   exec_sec = find_text_sec (elfh, sech);
   if ( elfh->e_entry < sech[exec_sec].sh_addr ||
        elfh->e_entry > sech[exec_sec].sh_addr + sech[exec_sec].sh_size )
   {
         printf ("KO: entry point not in text section!\n");
   }

7.3 .note Section Virus

Eine einfache Möglichkeit, ein Virus in ein Binary einzuschleusen ist, wenn man den Code in das .note.ABI-tag Segment einfügt, und dann den Type des Segment von NO-TE nach LOAD umändert, damit das Segment auch geladen wird. Auch muss man die Flags (Rechte) von Read (R) auf Read-Exec (RE) umändern, damit der Code auch ausgeführt werden kann.

Virus Beispiel: Lotek, von Wintermute

Code zur Erkennung:

   int count_load_segments (Elf32_Ehdr *elfh, Elf32_Phdr *prgh) {
   int n;
   int count=0;
   for (n=0; n<elfh->e_phnum; n++) {
      if ( (prgh[n].p_type == PT_LOAD) ) {
          count++;
      }
   }
   return(count)
   }
[...]
   n = count_load_segments (elfh, prgh);
   if (n > 2) {
      printf ("KO: too much loadable segments: %i\n", n);
   }

7.4 Segment Adding Virus

Ein Virus kann auch ein zusätzliches Segment erstellen, mit Type LOAD und Flags Read-Execute. Diese Technik ist ähnlich der .note Section Virus, ist aber umständlicher. Erkennung funktioniert aber genau gleich.

7.5 Text Section Append Virus

Mein Versuch, den Virus an die .text Section anzufügen, scheiterte kläglich. Der Grund war, dass sich eine weitere wichtige Section, .rodata, dahinter befindet, welche dem Programm statische Strings^{7} zur Verfügung stellt. Wird diese verschoben, findet das Programm die falschen Strings und funktioniert nicht mehr richtig.

7ein String ist eine aneinanderreihung von Buchstaben, also eine Zeichenkette

8 Der Linux Virenscanner

8.1 Benutzung

Die fundamentalen Erkennungsalgorithmen wurden schon in den vorherigen Abschnitten erläutert. Den Scanner ist einfach zu benutzen, man ruft ihn einfach mit dem Namen der zu scannenden Datei auf:

$ virus-scan /bin/ls

Das ergibt folgende Ausgabe, falls die Datei nicht infiziert ist:

OK: entry point in text segment
OK: entry point in text section
OK: Padding make sense
OK: number of segments

Falls sie z.B. mit dem sthlm Virus infiziert ist:

KO: entry point not in text segment
KO: entry point not in text section
OK: Padding make sense
OK: number of segments
File /bin/ls is probably infected. Errors: 2

8.2 Desinfektion - Schadensbegrenzung oder nicht?

Eine Desinfektion von infizierten Dateien wäre sicher angenehm, und ein wünscheswertes Feature eines Virenscanners. Es sprechen aber viele Gründe dagegen, das zu implementieren. Als erstes müsste der Scanner in der Lage sein, den Virus exakt zu identifizieren. Da ich aber nach allgemeinen Anzeichen von Viren suche, und nicht nach spezifischen Viren, ist das nicht effizient möglich. Eine Beschädigung der zu reparierenden Datei ist nicht auszuschliessen, und wäre z.B. auf einem Produktions Server fatal. Ausserdem ist die übliche, vernünftige Vorgehensweise bei einem Angriff auf ein System die komplette Neuinstallation dessen von einer sicheren Quelle. Man kann nie mit 100 prozentiger Sicherheit sagen, was nun alles am System verändert wurde. Evtl. bekam ein Attacker durch den Virus Root Zugang zum System, oder der Virus installierte irgendwo ein Backdoor. Desshalb ist die angemessenste Reaktion, mit einem virenverseuchten System umzugehen, dessen sofortige Neuinstallation.

9 Rechtliches

Wie in einem Artikel im TA vom 11. Sept 2003 nachzulesen, wurde ein Mann, der eine CD mit Anleitungen zum Virenbau verkaufte, zu 2 Monaten Gefängnis bedingt und 5000 Fr. Busse verurteilt. Tatbestand war Artikel 144bis StGB, ”Anleitungen zur Herstellung datenschädigender Programme ”. Irrelevant sei, ob die Abgabe der Informationen gratis oder gegen Entgelt erfolge, oder ob der Übermittler die entsprechenden Kenntnisse selbst erarbeitet oder bloss zusammengestellt hat. Irrelevant sei auch, ob die Anleitung vollständig sei. Es reiche schon aus, wenn ”Informationen zu wesentlichen Herstellungsvorgängen”abgegeben würden, und damit die Schaffung eines Virus ”wesentlich erleichtert”werde. Desswegen kann ich meine Viren nicht öffentlich publizieren, und darf leider hier auch keine Code Ausschnitte zeigen. Ob diese Art der Zensur gerechtfertigt ist, bleibt zweifelhaft. Da die hier beschrieben Techniken zur Virenabwehr selbstverständlich auch vom Studium existierender Viren oder Virenbau Anleitungen stammen und Virenmechanismen beschreiben, welche dazu genutzt werden können selber Viren herzustellen, würde auch diese Matura Arbeit unter dem vorher genannten Gesetzenartikel fallen.

10 Fazit

Sobald man das ELF Dateiformat und die Funktionsweise von Linux Viren verstanden hat, ist deren erkennung relativ einfach. Ist der Entry Point nicht in der .text Section, ist das Binary höchstwarscheinlich infiziert, entweder durch ein Virus oder durch ein anderes, bösartiges Programm. Viren, welche den Entry Point nicht verändern, lassen sich wie unter Windows nur durch Signaturen erkennen. Obwohl die funktionsweise des Viren Scanners im Prinzip einfach ist, ist es nicht einfach, die gesamte dahinterstehende Technik zu verstehen, und im Rahmen einer Maturaarbeit einfach darzustellen. Desshalb nehmen die Vorerklärungen auch den grössten Teil dieses Dokuments ein. Dass ich das Produkt meiner grössten Anstrengung, den Virus, nicht veröffentlichen darf schmerzt mich natürlich ein wenig. Trotzdem ist meine faszination für diese kleinen Viecher ungebrochen, genauso wie für das erforschen der Tiefen von Computer Betriebsystemen.

Dank An:

• Silvio Cesare, für seine informativen Emails

• Ratz, für seine Hilfe beim schreiben des Virus

• Jonny, für weitere Informationen zu ELF

Text geschrieben in L^{A}TEX mithilfe von VIM und xfig unter Linux und FreeBSD.

Eine Sammlung der benutzen Dokumente und Viren lässt sich unter

http://home.datacomm.ch/prutishauser/viren/

herunterladen.

11 Erklärung von Begriffen

1. Source Code: Der Source ist sozusagen die Anleitung für ein Programm. Der Source ist eine Aufzählung von Befehlen, die nachher etwas Bestimmtes machen, bzw. dann ein Programm ergeben. Der Source kann man mit einem einfachen Text Editor lesen, und besteht meistens aus an die englische Sprache angelehnten Befehle.

z.B:

  if (a < 100) {
    printf("zu klein\n");
  }

Bedeutet: Wenn die Zahl in Variable a kleiner ist als 100, drucke ”zu klein”auf dem Bildschirm aus. Programme, die im Sourcecode verbreitet werden, kann jeder selber erweitern oder verbessern.

2. Binary: Ein Binary ist ein kompiliertes Programm. D.h, der Sourcecode (siehe oben) wird in eine maschinenlesbare Form umgewandelt, die der Prozessor ausführen kann:

Obiges Beispiel wäre dann vielleicht:

10010010111010101101011001010101111...

Das kann man nur schwer in eine für Menschen lesbare Form umwandeln. Als erstes würde man es in Hexadezimal System basierende Schreibweise umwandeln:

  4f: 9a c4
  5f: ac 23
  ...

Die einzelnen Opcodes lassen sich noch in Assembler-Schreibweise darstellen. Obiges Beispiel wäre in etwa:

  cmp eax, 0x64
  jne noif
  mov eax, 0x1
  mov  ebx, 0x8048e80
  int  80h
noif:

3. Code:

In diesem Text steht Code für das ausfürbare Programm im Speicher.

12 Referenzen

Literatur

[1] The Linux Writing Howto, Alexander Bartolich

http://vx.netlux.org/lib/static/virus-writing-HOWTO/archive/

[2] The Linux Virus Writing And Detection HOWTO, Alexander Bartolich

http://vx.netlux.org/lib/static/virus-writing-HOWTO/archive/

[3] The Little Black Book of Computer Viruses Mark Ludwig, American Eagle Publication, 1996

http://vx.netlux.org/lib/vml00.html

[4] The Giant Black Book of Computer Viruses Mark Ludwig, American Eagle Publications, 1995

http://vx.netlux.org/lib/vml01.html

[5] The ELF Virus Writing Howto (2002), Alexander Bartolich

http://wizard.ae.krakow.pl/~wasylysp/txt/Virus_Writing_HOWTO/index.
html

[6] ELF Spezifikationen

http://x86.ddj.com/ftp/manuals/tools/elf.pdf

[7] System V Application Binary Interface

http://www.caldera.com/developers/gabi/latest/contents.html

[8] Is There any future for Linux Viruses?, Jakob Kaminski

http://conference.eicar.org/past_conferences/2001/papers/other/
Kaminski.pdf

[9] Viruses Revealed, David Harley, Robbert Slade and Urs E. Gattiker Osborne/McGraw-Hill, 2001

[10] Unix ELF Parasites and Virus, Silvio Cesare

http://www.u-e-b-i.com/silvio/elf-pv.txt

[11] Unix Viruses, Silvio Cesare

http://www.u-e-b-i.com/silvio/unix-viruses.txt

[12] Evil Elves, Marius van Oers

http://www.nai.com/common/media/vil/pdf/mvanoers_VB_jul2001.pdf

[13] Linux virus writing tutorial, mandragore

http://vx.netlux.org/lib/static/vdat/tulinuxv.htm

[14] Armouring the ELF: Binary encryption on the UNIX platform, grugq

http://www.phrack.org/phrack/58/p58-0x05

[15] The Cerberus ELF Interface, mayhem

http://www.phrack.org/phrack/61/p61-0x08_The_Cerberus_ELF_
interface.txt

[16] Linux vs. Windows Viruses, Scott Granneman

http://www.theregister.co.uk/content/56/33226.html

A Virus Ausführen ohne den Entry Point zu verändern

Wenn der Entry Point nicht in die .text Section zeigt, ist die warscheinlichkeit extrem hoch das ein Virus das Executable infiziert hat. Es wurden aber Techniken entwickelt, wie der Virus Code ausgeführt werden kann, ohne den Entry Point zu verändern:

• Opcode Patch Man könnte die ersten paar Bytes des Text (Code) Segmentes durch einen Jump auf den Virus Code ersetzen. Die überschriebenen Bytes werden dann im Virus gespeichert und nach seiner Ausführung wieder an ihre ursprüngliche Stelle zurückkopiert. Dorthin springt auch der Virus nach seiner Ausfürung. Wurde von Silvio schon mal gemacht, ist aber nicht ganz einfach, da Jumps auf i386 relativ sind. Man müsste also je nach Länge des Text + Data Segmentes den Opcode spezifisch erstellen.

• .ctor/.dtor Patch In der .ctor/.dtor stehen Adressen von Funktionen, die vor/nach der ausführung vom eigentlichen Programm aufgerufen werden. Der Aufbau ist folgender: 0xffffffff <function address> <another function address> 0x00000000 Diese Section sind immer vorhanden, auch wenn gar keine Funktionen eingetragen sind. Durch Ersetzen von 0x0000000 durch die Adresse des Virus Codes könnte er noch vor, bzw. nach dem eigentlichen Programm aufgerufen werden. Mehr Informationen gibt es im Text ”Overwriting the .dtors Section”, von Juan M. Bello Rivas.

• PLT/GOT Patching Die .plt (Procedure Linkage Table) und .got (Global Offset Table) werden gebraucht, um mit Hilfe des Dynamic Linkers Addressen von Externen Funktionen (Shared Librarys) herauszufinden. Durch Ersetzen von Adressen in der .got durch die des Virus kann man ihn auch ausführen. Mehr Informationen dazu gibt es im Text ”Shared Library Call Redirection via Elf PLT Infection”, von Silvio Cesare

B sthlm - ein Data Segment Append Virus

Wegen fehlender (funktionierender, und im Sourcecode vorhandener) Viren unter Linux hab ich mich entschlossen, einen eigenen zu Programmieren. Ein erster Versuch, den Virus Code an das Ende der .text Section einzufügen, scheiterte (da sich dadurch .rodata verschob, welche durch Absolute Adressierung im eigentlichen Programm adressiert wurde). Danach fügte ich ihn an das Ende des Data Segmentes an. Das macht ihn bis jetzt leicht entdeckbar (Entry Point im Data Segment), prädestinierte ihn aber auch zum Testen meines Viren Scanners. In späteren Versionen wird eine der oben genannten Stealth Mechanismen eingebaut werden. Wegen der Gesetzeslage in der Schweiz darf ich den Sourcecode leider nicht zur Verfügung stellen. Auch myth, ein einfacher, auch von mir geschriebener Overwrite Virus, kann ich leider nicht zum Studium bereitstellen. Wer trotzdem den Source einer dieser Viren haben will, kann mir eine E-Mail mit einer guten Begründung schreiben, oder sich im Computer Untergrund umhören.

C ELF C Strukturen

Aus /usr/include/elf.h

C.1 ELF Header

typedef struct
{
unsigned char e_ident[13];   /* Magic number and other info */
Elf32_Half    e_type;        /* Object file type */
Elf32_Half    e_machine;     /* Architecture */
Elf32_Word    e_version;     /* Object file version */
Elf32_Addr    e_entry;       /* Entry point virtual address */
Elf32_Off     e_phoff;       /* Program header table file offset */
Elf32_Off     e_shoff;       /* Section header table file offset */
Elf32_Word    e_flags;       /* Processor-specific flags */
Elf32_Half    e_ehsize;      /* ELF header size in bytes */
Elf32_Half    e_phentsize;   /* Program header table entry size */
Elf32_Half    e_phnum;       /* Program header table entry count */
Elf32_Half    e_shentsize;   /* Section header table entry size */
Elf32_Half    e_shnum;       /* Section header table entry count */
Elf32_Half    e_shstrndx;    /* Section header string table index */
} Elf32_Ehdr;

C.2 ELF Segment Header

typedef struct
{
Elf32_Word    p_type;        /* Segment type */
Elf32_Off     p_offset;      /* Segment file offset */
Elf32_Addr    p_vaddr;       /* Segment virtual address */
Elf32_Addr    p_paddr;       /* Segment physical address */
Elf32_Word    p_filesz;      /* Segment size in file */
Elf32_Word    p_memsz;       /* Segment size in memory */
Elf32_Word    p_flags;       /* Segment flags */
Elf32_Word    p_align;       /* Segment alignment */
} Elf32_Phdr;