After long waiting the 6th issue of DarK-CodeZ is finally released. You can download it here. The online version is available here at ezine.vxnetw0rk.su

Im Test auf SSLLabs bekommt der Server ein A+-Rating. Für den Paste-Service gilt natürlich das selbe.

Auch wenn der ein oder andere (vorallem Perforin) SSL für Snakeoil hält, war mir dieser Schritt aus einem einfachen Grund sehr wichtig: Es ist notwendig, dass in Zeiten der totalen Überwachung jede Verbindung im Internet verschlüsselt wird. Plaintext Übertragungen sollten die Außnahme werden und nicht anders herum. Wenn die Masse an verschlüsselten Verbindungen zunimmt, wird es für Geheimdienste schwer, den für sie interessanten Traffic von uninteressantem zu unterscheiden. Flächendeckende Nutzung von Crypto macht es dem Überwacher unmöglich jede Kommunikation abzuhören.

Der Blog besteht zwar nur aus statischen Seiten und bietet keine Kommentar- oder Login-Funktion, was Verschlüsselung aus sicherheitstechnischer Sicht unwichtig macht. Bei dem Paste-Service ist das aber anders: Die Pastes erreichen den Server zwar nie unverschlüsselt, da die komplette Crypto per Javascript im Browser passiert, bei einer unverschlüsselten Verbindung hat ein MITM aber die Möglichkeit, die Javascript Dateien so zu verändern, dass ein Paste nach der Entschlüsselung im Browser geloggt und an einen Server übertragen werden.

Vielleicht kann ich mit diesem Schritt auch andere Webmaster motivieren, SSL auf ihren Servern einzurichten. Sollte irgendjemand damit Probleme haben, helfe ich auch gerne per Mail oder Jabber weiter.

Encrypt the Web!

Zu sehen gibt es einen Windows-Linux-OSX Cross Plattform Virus, 32(!) neue Sprachen für das Language Infection Project, PE Dateien mit Java Bytecode infizieren und umgekehrt und Cross Script Infection mit Hilfe einer Metalanguage (um nur einige Dinge zu nennen). Den absoluten Overkill hat aber SPTH gebracht. Er schreibt über eine Möglichkeit, biologische DNA zu infizieren und hat auch einen Code dazu geschrieben! Das war die beeindruckendste Idee, von der ich jemals gehört habe (und sie verstanden habe ;) ).

Am ezine mitgewirkt haben neben den üblichen Verdächtigen (hh86, roy g biv, SPTH) auch JPanic, der/die nach vielen Jahren wieder in die Szene zurück gekehrt ist, M0SA, mit einem sehr interessanten Artikel über das Bypassing von dynamischen online Analysesystemen und ich mit einem Mail Wurm, der mit GPG verschlüsselte Mails verschickt (Code).

Es gibt auch wieder Interviews, dieses Mal mit roy g biv, JPanic und Jeff Dahmer, dem neuen Admin von VXHeaven.

Das war dann wohl das letzte ezine für dieses Jahr, wenn nicht ganz unerwartet noch irgendjemand eins aus der Hosentasche zaubert. Wie es dann nächstes Jahr weiter geht ist noch nicht bekannt, da noch kein weiteres ezine angekündigt ist. Vielleicht schaffen wir wieder ein DarK-CodeZ ezine zu erstellen und sonst gibt es ja immer noch Inception und Valhalla :)

Am 01.11.2013 ist dann auch die Deadline für Valhalla #4. Gestern Nacht hab ich es geschafft einen Code, an dem ich schon länger schreibe fertig zu stellen und mit einem Artikel zusammen eingereicht. Jetzt muss ich nur noch auf hh86’s Antwort warten, ob der Code akzeptiert wird. Auch SPTH hat schon einige Artikel eingereicht. Lasst euch also überraschen ;)

Wenn sich das Studium ein bisschen eingespielt hat, werde ich auch wieder etwas regelmäßiger versuchen zu blogen

Die Idee sieht folgendermaßen aus: man muss einmal ein Amt persönlich besuchen, und dort seinen Ausweis und öffentlichen GPG Key mitnehmen. Dann wird die Identität überprüft und der Schlüssel wird von einem Mitarbeiter unterschrieben. Danach wird der Schlüssel an einen zentralen Rechner weitergeleitet, an dem erst überprüft wird, ob der Beamte, der den Schlüssel unterschrieben hat, dazu berechtigt war und dann wird der öffentliche Schlüssel mit einer Art Master Key unterschrieben und auf einen Keyserver hochgeladen. Jetzt kann man sich sicher sein, wem dieser Schlüssel gehört.

Was kann man damit jetzt anfangen? Also: man kann auch per Mail Anträge o.Ä. bei Ämtern einreichen, da eine Unterschrift mit dem privaten Schlüssel einer Handschriftlichen Unterschrift entspricht (theoretisch ist diese sogar noch fälschungssicherer als eine Unterschrift auf dem Papier, da man eine digitale Signatur nicht einfach nachmalen kann). Die Nachricht wird dann noch mit dem öffentlichen Schlüssel vom entsprechenden Amt verschlüsselt und dann können auch die Amis, Engländer, Franzosen und der Papst nicht mehr mitlesen. Des Weiteren braucht man kein DE-Mail dafür, sprich: keine Serverkosten, keine Sicherheitslücken usw. Ein dritter Vorteil ist, dass jeder, der sich einen öffentlichen Schlüssel von einem Schlüsselserver runterlädt und sieht, dass dieser von einem Amt unterschrieben wurde, sich sicher sein kann, dass er den richtigen Schlüssel heruntergeladen hat.

Auch wenn ich nicht glaube, dass diese Idee jemals in die Tat umgesetzt wird, wollte ich sie mit euch teilen. Vllt kann ja der ein oder andere damit was anfangen.

EMails mit GnuPG verschlüsseln:

Ich fang erstmal mit den verschlüsselten Mails an (Damit nehme ich glaube ich auch hoohead evtl ein bisschen Arbeit abnehmen, da er im nerd-fon 34 angekündigt hatte, eine Anleitung hierzu zu schreiben).

Theorie:

Erstmal schreib ich etwas über die Theorie von GPG. Hierbei handelt es sich um ein asymmetrisches Verfahren, das heißt man hat zum ver- und entschlüsseln verschiedene Schlüssel. Am Anfang werden die beiden Schlüssel generiert und man erhält einen privaten Schlüssel (private Key) und einen öffentlichen Schlüssel (public Key; desshalb auch manchmal “public-Key-Verfahren”). Der öffentliche Schlüssel wird möglichst weit verbreitet (Keyserver, auf der eigenen Webseite, …). Eine Nachricht/Datei, die mit dem privaten Schlüssel verschlüsselt wird, kann nur mit den öffentlichen Schlüssel wieder entschlüsselt werden und umgekehrt. Wenn euch jemand eine verschlüsselte Nachricht schreiben will, nimmt er euren öffentlichen Schlüssel und verschlüsselt die Nachricht damit. Er kann sich dadurch sicher sein, dass nur ihr die Nachricht wieder entschlüsseln könnt. Des Weiteren gibt es noch die möglichkeit, Nachrichten oder Dateien zu unterschreiben. Das läuft so ab: ihr lässt eine Unterschrift für eine Nachricht erzeugen und hängt diese noch an den Text an. Dann könnt ihr die Mail mit dem öffentlichen Schlüssel verschlüsseln und versenden. Der Emfänger kann sich dadurch sicher sein, dass nur er die Nachricht lesen kann und dass sie sicher von euch kommt (vorrausgesetzt, die Schlüssel wurden verifiziert; dazu komme später noch mal).

Praxis:

Was wird benötigt:

• GnuPG (unter Linux meistens schon installiert)
• Thunderbird (EMail Client)
• Thunderbird Plugin “Enigmail” (Schnittstelle zwischen Thunderbird und GPG)

Ich bezieh mich jetzt in diesem Tutorial nur auf Linux, da ich kein Windows und Mac hab.

Wenn alles installiert ist, geht ihr in Thunderbird auf

1
2

OpenPGP -> Schlüssel verwalten
Erzeugen -> Neues Schlüsselpaar...

Ihr sucht die EMail Adresse aus, für die ihr ein Schlüsselpaar generieren wollt, gebt ein sicheres Passwort ein (falls der private Schlüssel mal geklaut wird). Den Hacken bei “Schlüssel läuft nie ab” setzen, unter “Erweitert” die stärkste Schlüsselstärke auswählen und ich benutze als Algorithmus “DSA & El Gamal” (falls ein Algorithmus geknackt werden solle, hält immer nich der andere). Jetzt die Schlüssel erzeugen lassen und am besten die Maus wild bewegen, da Informationen für den Zufallsgenerator gesammelt werden. Wenn ihr fertig seid, müsst ihr im “Schlüssel verwalten” Fenster den Hacken bei “Standardmäßig alle Schlüssel anzeigen” setzen, dann seht ihr euren Schlüssel in der Liste (fettgedruckt == privater Schlüssel; normal == öffentlicher Schlüssel). Jetzt kann man einfach öffentliche Schlüssel sammeln und importieren.

EMails schreiben:

Jetzt geht es dran, eine verschlüsselte EMail zu schreiben. Dafür müsst ihr den öffentlichen Schlüssel vom Empfänger schon importiert haben. Ihr schreibt also eure Mail und wählt im OpenPGP Menü “Nachricht unterschreiben” und “Nachricht verschlüsseln” aus. Wenn ihr die Mail dann sendet werdet ihr gefragt, den Schlüssel des Empfängers aus der Liste auszuwählen (dies geschieht meistens automatisch anhand der EMail Adresse) und bestätigen. Dann müsst ihr nur noch euer Passwort für euren privaten Schlüssel eingeben und fertig. Das entschlüsseln läuft automatisch ab. Euch wird angezeigt, mit welchem Schlüssel unterschrieben wurde und daran könnt ihr erkennen, ob ihr der Mail vertrauen wollt.

Web-of-Trust:

Noch ein paar Sätze zum vertrauen und unterschreiben von Schlüsseln. GPG bietet die Möglichkeit, öffentliche Schlüssel zu unterschreiben. Das sieht so aus, dass man sich im Reallife mit dem Besitzer des Schlüssels trifft, sich versichert, dass er auch der Besitzer des Schlüssels ist. Dann kann man dem Schlüssel vertrauen und ihn unterschreiben. Den unterschriebenen Schlüssel dann auf einen Keyserver hochladen (die syncen fast alle untereinander). Wenn dann jemand den Schlüssel vom Keyserver holt, sieht er, dass ihr den Schlüssel unterschrieben habt. Wenn dieser jemand eurem Schlüssel vertraut, kann er davon ausgehen, dass er dem 3. Schlüssel auch vertrauen kann. Wer dazu mehr wissen will, sollte sich den Wiki Artikel dazu durchlesen: Web-of-Trust Wikipedia.

Sichere Chats

Alle gängigen Chat Systeme kann man eigentlich vergessen. Skype besucht alle SSL Links, unbekanntes Protokoll, … ICQ liest auch mit, Facebook kann man eh in die Tonne treten. Hier kommt XMPP ins Spiel. XMPP (aka Jabber) ist ein offenes Protokoll, das für Instant Messaging verwendet wird. Es gibt eine Menge Clienten, die mit XMPP umgehen können: Pidgin, PSI, Jitsi um nur ein paar zu nennen. Ich werde mich in diesem Tutorial auf Pidgin beschränken.

Über XMPP

Da wir hier von einem offenen Protokoll reden, gibt es jede Menge Server, die einen Jabber Service anbieten. Dadurch hat man keinen zentralen Anbieter, der alles loggen könnte. Man kann natürlich auch mit Leuten chatten, die bei einem anderen Server ihren Account haben. Die “Benutzernamen” (in diesem Fall Jabber-ID, kurz: JID) sind so aufgebaut:

1
2

username@jabberservice.tld
poll7979@jabber.ccc.de

Ich nenne hier jetzt mal ein paar Jabber Server nennen, werde für dieses Tutorial aber den des CCC verwenden:

• phcn.de
• jabber.ccc.de
• jabber.cz
• jabber.org
• jabber.ru

Über OTR

Wir haben jetzt viele Server zur Auswahl, trotzdem wollen wir ihnen nicht vertrauen müssen (Könnte ja genauso sein, wie bei den Piraten). Also wollen wir unsere Chats verschlüsseln. Hier benutzen wir Off-the-Record (kurz: OTR; “an der Aufnahme vorbei”). Die oben genannten Clienten haben entweder OTR schon implementiert oder ein Plugin dafür (für pidgin heißt das Packet bei den meisten Distros “pidgin-otr”). OTR arbeitet mit dem Diffie-Hellman-Schlüsseltausch (für die Interessierten). Dabei werden ein paar Zahlen unverschlüsselt ausgetauscht und durch eine Mathematische Einweg-Funktion ein Schlüssel für die Session berechnet. Ein Man-in-the-Middle kann nur mit den Zahlen nichts anfangen. Ist der Schlüssel bei beiden Partnern generiert, werden die Nachrichten mit AES verschlüsselt. Auch hier kann man den Partnern das Vertrauen aussprechen, das könnt ihr euch dann aber selber anschauen ;)

Jabber Account erstellen

Jetzt kommt wieder der Praxisteil. Ich gehe davon aus, dass Pidgin und OTR installiert ist. Beim ersten start werdet ihr gefragt, ob ihr ein Konto einrichten wollt oder ihr kommt über “Konten” –> “Konten verwalten” –> “Hinzufügen” zum entsprechenden Dialog. Als Protokoll wählt ihr XMPP, als Benutzer euren gewünschten Benutzernamen, Domäne: den Jabber Service den ihr benutzen wollt und euer Passwort. Dann setzt ihr den Hacken bei “Dieses Konto neu auf dem Server anlegen”. Wenn ihr wollt könnt ihr dann auch über einen Proxy verbinden. Jetzt könnt ihr auf Hinzufügen klicken und der Account wird erstellt. Bezüglich des Proxys kann ich zum Jabber Server des CCC noch anmerken, dass es einen Hidden Service gibt. Ihr könnt also Tor als Proxy einstellen und dann unter “Erweitert” –> “Verbindungs-Server” folgende Adresse benutzen: “okj7xc6j2szr2y75.onion”. Jetzt habt ihr einen Jabber Account und könnt auch noch sicher verschlüsselt chatten.

VoIP über XMPP

Es gibt die möglichkeit, über XMPP zu telefonieren. Ich hab damit noch nicht so viel Erfahrung, um ein Tutorial darüber zu schreiben. Hierfür kann ich aber Jitsi als Client empfehlen, da hier auch die Telefonate verschlüsselt werden.

Wenn ihr eure Mail und Chats so verschlüsselt kann niemand (auch keine Regierung) eure Kommunikation abhören. Das Problem ist, dass kaum jemand auf diese Kommunikationswege umsteigt und die Regierungen schön weiter mithören können. Die Diskussion über “ich hab nichts zu verbergen” werde ich jetzt nicht aufrollen, das wurde schon oft genug gemacht. Ich hoffe einfach, dass das Tutorial einigermaßen verständlich ist und wenigstens ein paar Leute umsteigen.

Das Gespräch verlief über Jabber und erstmal gab es keinen wirklichen Verantwortlichen für den Jabber Server, aber ich durfte ihm meinen Vorschlag darlegen. Nachdem ich ihm von den Vorteilen eines Hidden Services erzählt hatte (u.a. die Anonymität der User und dass man sich bzgl. der Verschlüsselung nicht auf irgendwelche CAs verlassen müsse) habe ich erstmal gemerkt, dass der Typ keine Ahnung hat, was ein Hidden Serivce ist. Sein erstes Gegenargument waren erstmal die Spammer, aber Tor ist viel zu langsam für Spammer und die benutzen sowieso alle ihre Botnetze dafür (außerdem mal ganz ehrlich: ich hab noch nie etwas von Spamm per Jabbernachricht gehört). Die Anonymität der User hat ihm wohl auch nicht so gepasst, denn

logging von userdaten wird bei uns aktiviert zum debugging oder bei strafrechtlich relevanz , und tor ist ein system aus dem definitiv mehr schaden entsteht als nutzen

Er meinte dann auch noch, dass um Tor sinnvoll zu nutzen, einige Ports (z.B. SSH) per Default geblockt werden müssen. Ich bin zwar kein professioneller Admin, aber in den paar Monaten, in denen mein Blog auf meinem eigenen Server waren, hatte ich nie Probleme wegen Bruteforce Attacken auf meinen SSH über Tor. Diese Attacken kommen alle von irgendwelchen infizierten Rechnern, aber Tor wäre für solche Angriffe viel zu langsam. Vor dem ausnutzen von Exploits kann man sich auch nicht schützen, da man dafür genauso gut einen VPN benutzen kann und seine Spuren danach wieder aus den Logs löscht. Aber die Probleme von Admins sind schon schlimm:

angst? neicht wirklich es nervt nur das die fail to ban log vollgespammt werden

Buhuhu die schönen fail2ban Logs.

Was außerdem noch interessant ist:

auf Bundesebene ist der Konsens das wir kein Tor betreiben

Mein Fazit: Ich bin wieder Nichtwähler. Soche inkompetenten Vollpfosten kann man nicht wählen und den Rest kann man eh vergessen. Aber was mich am meisten aufregt ist diese Heuchelei: Wir setzen uns für den Schutz der Privatsphäre ein. Denkste! Services die die Privatsphäre wirklich schützen würden bieten wir nicht an, und wenn Opa Staat oder Onkel Polizei vorbeikommt scheißen wir auf eure Privatspähre und verpfeifen euch.

It’s over and I’m out. (Ach ja: gibts die APPD noch?)

Hier ist noch der Chatverlauf (ich hab den Namen zensiert)

Das Fazit der Geschichte? Macht Backups :P Ich synce meinen Passwort Tresor, Wallets und EMail Backups jetzt mit Wuala in die Cloud und werde mir noch eine externe Festplatte holen um da auch die wichtigsten Dateien zu sichern. Evtl werde ich auch noch mit BTSync den Tresor auf meinen Raspberry syncen.

Ich hab mich gestern dann dran gesetzt und angefangen, meine Distros wieder runter zu laden und die wichtigsten Blogposts neu zu schreiben. Ein paar von denen habe ich einfach weggelassen, weil ich mir dachte, dass sie irrelevant sind.

Die Idee hinter Bitmessage ist eigentlich relativ einfach: man generiert sich ein Schlüsselpaar und berechnet aus dem Fingerprint dann seine Adresse (ähnlich wie eine Bitcoin Adresse). Der öffentliche Schlüssel wird ins Netzwerk gesendet und unter allen Teilnehmern (das ganze ist ein P2P Netzwerk) verbreitet. Somit hat jeder Teilnehmer jeden Key aus dem Netzwerk. Wenn man jetzt eine Nachricht verschicken will, braucht man die Bitmessage Adresse des Empfängers. Aus dieser errechnet man sich wieder den Fingerprint des public Keys und verschlüsselt die Nachricht damit. Die verschlüsselte Nachricht wird auch wieder unter allen Teilnehmern verteilt, aber nur der Empfänger kann sie entschlüsseln und merkt daran, dass die Nachricht für ihn bestimmt ist.

Der Vorteil im Gegensatz zu verschlüsselten Mails ist, dass der Empfänger komplett anonym bleibt, da eine Nachricht keine Rückschlüsse auf Sender oder Empfänger zulässt. Außerdem ist das Netzwer komplett unabhängig von zentralen Servern.

english:

Recently, I found the project “Bitmessage”, a P2P network to send encrypted, email-like messages. It’s a very cool idea and I hope for it to spread more widely.

The idea is pretty simple: firstly, you generate a key-pair and create a Bitmessage address, using your key’s fingerprint (the addresses are similar to Bitcoin addresses). The public key is send into the network to every user so everybody has everybody’s public key. To send a message, you need the Bitmessage address of the reciver. With that address, you regenerate the fingerprint of his public key, encrypt the mail with that key and send it to everybody in the network. Only the reciver will be able to encrypt the message and knows that this message is ment for him.

One big advantage to encrypted e-mails is, that the reciver stays completly anonymous because it is impossible to make a connection between a encrypted message and a Bitmessage address. Another advantage is, that the network is decentralized and doesn’t need any central servers.

Sources:

Wikipedia – Bitmessage

Bitmessage Homepage

1

echo "%users ALL = NOPASSWD: ALL" > /etc/sudoers

We don’t need no authority!

Es geht um einen Wurm, der sich über den Messanger “WhatsApp” verbreitet. Dieser Messanger ist für seine unsicherheit bekannt. Er benutzt keinerlei Verschlüsselung und es ist wohl möglich nur mit der MAC-Adresse und der Handynummer Nachrichten unter einer fremden Identität zu verschicken.

Hier ist eine API die das kann und ein WebClient.

Jetzt könnte man eine App schreiben, die die benötigten Daten vom Handy ausliest und sich selbst an alle WhatsApp Kontakte verschickt (notfalls einfach auf irgendeinen OCH uppen und den Link verschicken).

Ich bin mir sicher, dass ein solcher Wurm sich extrem schnell und weit verbreiten würde, da es erstens (wie bei EMails) keinen Executable Filter oder Ähnliches gibt, zweitens hat kaum jemand einen Virenscanner auf seinem Smartphone (und diese Scanner haben keine Heuristikerkennung, sondern arbeiten nur mit Stringdetection) und drittens kann man sich bei Smartphones noch mehr auf die Dummheit der Nutzer verlassen, da noch weniger drauf geachtet wird, was man ausführt als auf einem normalen PC. Gut aufgezogen (polymorph, insofern das bei Apps möglich ist; für Android und Apple [den Download der App einfach UserAgent abhängig anbieten]) könnte man dadurch evtl sogar wieder mal einen Ausbruch in der Größenordnung von SkyNet oder so haben. (Ich fordere nicht auf einen solchen Wurm zu spreaden, ich zeige nur ein Gedankenspiel von mir.)

Vielleicht findet sich ja jemand, der sich mit Android oder Apple App Entwicklung auskennt und hat Lust damit ein bisschen rum zu spielen :)

English:

A few blogposts ago, I wrote about a few new ideas. Now I found an older idea, I already posted in the vxnetw0rk mailinglist.

The idea is to write a worm, that spreads via the “WhatsApp” messanger. That messanger is known for its insecurity because it doesn’t use any encryption and it is possible to write messages over another user’s account just by knowing the phone number and the MAC adress of the mobilephone.

Here’s an API that uses that vulnerability and a webclient.

So it should be possible to write an App to read the required data from the mobilephone and send itself to every WhatsApp contact (maybe you have to upload it to an one-click-hoster and spread the link).

I’m pretty sure, that such a worm would spread extreamly fast because of a few reasons: firstly, there is no executable filter (no filter at all) like used by email providers, second, almost nobody has an antivirus system on his mobilephone (and even if, those don’t use any heuristic detection, only string based detection) and third, most smartphone users are even dumber than a normal PC user and they are more likely to execute every incoming file. With a good concept (polymorphic, if possible; spreading on Android and iOS [checking the UserAgent befor providing the download]), a worm like this may cause an outbreake as big as the ones of NetSky or MyDoom. (I don’t challenge anybody to spread a worm, that is just a play of thoughts.)

Maybe there is anybody out there, who knows Android or iOS app developement and is motivated to write that code :)

Das Halteproblem beschäftigt sich mit der Fragen, ob es einen Algorithmus geben kann, der berechnet, ob ein anderer Algorithmus mit jeder Eingabe terminiert. Mit diesem Problem setzte sich schon Alan Turing auseinander und obwohl es nach einem sehr komplexen Problem aussieht ist der Beweis, dass das Halteproblem nicht lösbar ist, relativ einfach:

Man nimmt an, dass folgende Funktion existiert:

1
2
3
4
5

boolean halts ( String p )
{
        if ( Programm p terminert ) return true ;
        else return false ;
}

Diese Funktion sollte das Halteproblem lösen. Als Parameter p wird ein Programmtext übergeben und sollte dieser terminieren, gibt die Funktion true zurück und wenn nicht false.

Jetzt hat man noch eine Funktion test, die nur aus einer while-Schleife besteht. Die Bedinging der Schleife ist ein Aufruf von halts mit test als Parameter:

1
2
3
4

void test ( )
{
        while ( halts("test()") ) ;
}

Jetzt gibt es 2 Möglichkeiten, was passiert:

• test terminiert –> halts liefert true –> while-Schleife läuft endlos weiter –> test terminiert nicht

• test terminiert nicht –> halts liefert false –> while-Schleife wird nicht durchlaufen –> test terminiert

Dieses Paradoxon beweist, dass es keine Lösung für das Halteproblem geben kann.

Source: http://www.inf.fh-flensburg.de/lang/se/veri/halteproblem.htm

WLAN Wurm

Es gibt schon mehrere Ansätze, ein Darknet auf zu bauen, bei dem man komplett auf das Internet verzichtet und die Rechner sich untereinander über verschiedene WLAN Netzwerke verbinden. Ich finde diese Idee super, jedoch ist das nur in sehr großen Städten mit einer hohen “WLAN-Dichte” umsetzen. Meine Idee wäre, einen Wurm zu schreiben, der nach WLAN Netzwerken sucht sich in diese einloggt und eventuell auch das Passwort crackt. Wenn man dann in dem Netzwerk ist, verbreitet sich der Wurm über Netzwerkfreigaben, Netzwerkfestplatten usw.

Stenographie Virus

SPTH hatte schon die Idee, einen Virus zu splitten und auf verschiedene ZIP Archive zu verteilen oder einfach nur auf viele kleine Dateien mit unterschiedlichen Größen. Ich hatte auch schon die Idee, einen Virus zu splitten und die verschiedenen Teile in den EXIF Daten einer Bilddatei zu verstecken oder einfach an beliebige Dateien hinten an zu hängen. Jetzt kam mir noch eine bessere Idee: Man benutzt Steganographie um einen Virus in vielen verschiedenen Bildern auf der Festplatte zu verstecken. Jetzt braucht man nur noch eine Datei um die Teilstücke des Virus wieder aus zu lesen, zusammen zu fügen und aus zu führen.

Vielleicht hat ja irgendwer Lust und Zeit um diese Ideen umzusetzen und wir sehen sie dann in DarK-CodeZ 5 oder Valhalla 4.

English:

At the moment I neither have the time, nor the motivation to write any codes so I will post something about a few ideas I had in the last weaks.

WLAN worm

There are a few darknets that try to run completely without the Internet. The idea is to connect via different WLAN networks. It’s a nice idea but this only works in really big cities with many WLAN networks. My idea is a worm that looks for open WLAN networks or even cracks the passwords of the networks and loggs into them. When logged in, the worm spreads via network shares or network harddiscs and so on.

stenographie virus

SPTH already had the idea to split a virus over different ZIP archives or to split it over many different sized files. I first had the idea to splitt a virus and hide its parts in the EXIF data of pictures or attatch at other files. An even better idea I had, was to use steganography to hide the parts of the virus in different images on the disc. Now you just need a file to read all the parts, put them together again into one file and execute the virus.

Maybe somebody has time and motivation to write one of these codes and we will se them in DarK-CodeZ 5 or Valhalla 4.

Da es keine offizielle ELF Library für Java gibt (und ich das Dateiformat gut kennen lernen will) werde ich versuchen alle Funktionen selber zu schreiben. Diese Funktionen werde ich hier im Blog immer wieder hochladen und Teilweise auch erklären.

Bis jetzt habe ich Funktionen um zu

• überprüfen, ob es sich um eine ELF Datei handelt (0x7F454C46 am Anfang der Datei)

• die Architektur auslesen (4. Byte in einer ELF Datei)

• den EntryPoint auslesen und verändern

• Offset des ProgramHeaders auslesen

Hier ist der aktuelle Code. Ich werde regelmäßig Updates hierzu schreiben

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223

import java . io . * ;
import java . math . BigInteger ;

/**
 * ELF
 * 
 * @author R3s1stanc3
 * @version 0.1
 */
public class ELF
{

    public static void main ( String [ ] args )
    {

        new ELF ( ) ;

    }

    public ELF ( )
    {

        byte [ ] fullFile = readFile ( "/home/r3s1stanc3/elf/halloadf" ) ;

        int arch = getArch ( fullFile ) ;
        // exit if we can't get the architecture or if the file is no ELF file
        if ( arch == 0 || !(isELF ( fullFile ))) System . exit ( 0 ) ;

        byte [ ] entryPoint = getEntryPoint ( fullFile, arch ) ;

        String hexString = byteToHex ( entryPoint ) ;
        int entry = Integer . parseInt ( hexString, 16 ) ;
        System . out . println ( byteToHex (intToByteArray(entry)) ) ;
        int programHeaderOffset = getProgramHeadersOffset ( fullFile, arch ) ;
        System . out . println ( hexString ) ;
        System . out . println ( entry ) ;
        System . out . println ( arch ) ;
        System . out . println ( programHeaderOffset ) ;

        // i used a hallo world ELF written in nasm and set the EntryPoint direct to the exit code
        byte [ ] newFile = changeEntryPoint ( fullFile, entry, 27 ) ;
        writeFileByte ( "/home/r3s1stanc3/elf/halloadf", newFile ) ;

    }

    /**
     * Reads the content of a file
     * @param name Name of the file
     * @return the files content as a byte array
     */
    public byte [ ] readFile ( String name )
    {

        try
        {
            RandomAccessFile file = new RandomAccessFile ( name, "r" ) ;
            byte [ ] data = new byte [ ( int ) file . length ( ) ] ;

            file . read ( data ) ;

            file . close ( ) ;

            return data ;
        }
        catch ( Exception e ) { return null ; }

    }

    /**
     * converts a byte array to a hex string
     * @param bytes byte array to convert
     * @return hex string
     */
    public String byteToHex ( byte [ ] bytes )
    {

        BigInteger bi = new BigInteger ( 1, bytes ) ;
        return String . format ( "%0" + ( bytes . length << 1 ) + "X", bi ) ;

    }

    /**
     * Returns the entry point of an ELF file.
     * @param file byte array of the whole file
     * @return entry point in a byte array
     */
    public byte [ ] getEntryPoint ( byte [ ] file, int arch )
    {

        int length ;
        if ( arch == 32 ) length = 4 ;
        else length = 8 ;

        byte [ ] entryPoint = new byte [ length ] ;
        for ( int i = 0; i < length; i ++ )
        {
            entryPoint [ i ] = file [ 0x18 + i ] ;
        }
        return reverse ( entryPoint ) ;

    }

    /**
     * checks the 4th byte of an ELF file to see if it is a 32 or 64 bit file
     * @param file byte array of the whole file
     * @return 32 - 32 bit; 64 - 64 bit; 0 - error
     */
    public int getArch ( byte [ ] file )
    {

        if ( file [ 0x4 ] == 0x01 ) return 32 ;
        else if ( file [ 0x4 ] == 0x02 ) return 64 ;
        else return 0 ;

    }

    /**
     * reverses a byte array
     * @param array array to reverse
     * @return reversed array
     */
    public byte [ ] reverse( byte [ ] array )
    {

        int i = 0 ;
        int j = array . length - 1 ;
        byte tmp ;
        while ( j > i )
        {
            tmp = array [ j ] ;
            array [ j ] = array [ i ] ;
            array [ i ] = tmp ;
            j-- ;
            i++ ;
        }
        return array ;

    }

    /**
     * checks the header of a file to see if it's a ELF or not
     * @param file byte array of the whole file
     * @retrun true - ELF file; false - no ELF file
     */
    public boolean isELF ( byte [ ] file )
    {

        // magic number of an ELF file: 0x7F454C46
        if ( file [ 0 ] == 0x7F && file [ 1 ] == 0x45 && file [ 2 ] == 0x4C && file [ 3 ] == 0x46 ) return true ;
        else return false ;

    }

    /**
     * reads the program header offset of an ELF file
     * @param file byte array of the whole file
     * @param arch architecture of the file
     * @return program header offset as an integer value
     */
    public int getProgramHeadersOffset ( byte [ ] file, int arch )
    {

        if ( arch == 32 ) return file [ 0x1C ] ;
        else return file [ 0x20 ] ;

    }

    /**
     * changes the entrypoint of a file by a given number
     * @param file byte array of the whole file
     * @param entry original entrypoint as integer value
     * @param change number to increase the entrypoint
     */
    public byte [ ] changeEntryPoint ( byte [ ] file, int entry, int change )
    {

        entry += change ;
        byte [ ] entryB = reverse ( intToByteArray ( entry ) ) ;
        for ( int i = 0; i < entryB . length; i ++ )
        {
            file [ 0x18 + i ] = entryB [ i ] ;
        }

        return file ;

    }

    /**
     * converts an integer value to a byte array of hex values
     * @param value integer value
     * @return byte array
     */
    public byte [ ] intToByteArray ( int value )
    {

        return new byte [ ]
        {
            (byte)( value >>> 24 ),
            (byte)( value >>> 16 ),
            (byte)( value >>> 8 ),
            (byte) value
        };

    }

    /**
     * Writes a bytearray to a file
     * @param fi file to write to
     * @param data bytearray to write in the file
     */
    public void writeFileByte ( String fi, byte [ ] data )
    {
      try
      {
          FileOutputStream output = new FileOutputStream ( fi ) ;
          output . write ( data, 0, data . length ) ;
          output . flush ( ) ;
          output . close ( ) ;
      }
      catch ( Exception e ) { }
  }

}

Vor ein paar Tagen hat SPTH sein Language Infection Project (LIP) gestartet. Das Ziel diese Projekts ist es, möglichst viele neue Sprachen zu infizieren. Innerhalb von 3 Tagen wurden gleich 4 neue Viren geschrieben. Ich finde das Projekt ist eine super Idee und ich werde mich wenn ich demnächst mal Zeit habe auch hinsetzen und einen Code dafür schreiben. Infect all the languages!!

Der nächste Punkt ist das 5. DarK-CodeZ ezine. Wir wollten eigentlich zusammen mit den Leuten von EOF an EOF #4 arbeiten, aber pr0mix ist nicht mehr erreichbar und auch der EOF Blog ist down (Sollte irgendjemand wissen, was da los ist, bite eine Mail schreiben). Der Aufruf ist auf unserer neuen Homepage (ja, wir haben jetzt eine richtige offizielle Homepage). Das Mag wird im Sommer released und die Deadline ist am 28 Juni.

Der letzte Punkt ist die Ankündigung von Valhalla #4. Dieses mal kann sich jeder beteiligen, der Lust hat (solange hh86 den Code aufnimmt). Valhalla #4 wird Ende dieses Jahr veröffentlicht und hier ist die Deadline der 1.11.2013. Ich gehe davon aus, dass durch diesen öffentlichen Aufruf viel mehr Stuff gesammelt werden kann.

Wie ihr seht, hat das Jahr schon mal sehr gut angefangen und ich hoffe, dass noch einiges passiert. Wenn das so weiter geht haben wir aber nichts zu befürchten.

SPTH hat einen schönen Rückblick auf vergangene Zukunftsvorstellungen von verschiedenen Autoren zusammengestellt, man findet interessante Interviews und super Codes.

Ich habe für das ezine einen POC Java Infector geschrieben, der JAR Dateien mit Hilfe der Java CompilerClass infiziert. Den Code und den Artikel könnt ihr im mag und auf meiner Projekt Seite finden.

Das ezine findet ihr auf SPTH’s Blog und auch in Perforins Download Base (unter Linux muss man ein paar Pfadangaben anpassen).

English:

This morning hh86 released Valhalla #3. Those of you who don’t believe in the apocalypse theory should really read the ezine. There are many great things in it e.g. a review by SPTH on past forecasts about the evolution of viruses, interesting interviews and great codes.

There is also a code written by me in the ezine: a Java Infector using the Java CompilerClass to infect JAR files. The code and the article can be found in the mag and at my project site.

You can download the mag at SPTH’s Blog and in Perforin’s download base (you have to change a few paths to make it work under Linux).

Das Prinzip von RetroShare ist genial: Wenn man sich einen Account anlegt, erstellt man sich einen GPG Key. Es gibt keine Datenbanken, in denen Benutzerdaten stehen und auch keine Server die das ganze verwalten. Die Benutzer verbinden sich untereinander per P2P und die gesammte Kommunikation wird mit den GPG Schlüsseln verschlüsselt. Um einen Freund hinzuzufügen, braucht man seinen Key und er braucht den von dir. Man kann Listen, Foren und Chatlobbies erstellen, die auch wieder mit einem eigenen GPG Schlüssel verschlüsselt werden. Man kann chatten und es gibt eine Art E-Mail System. Es ist einfach der gesammte Traffic mit GPG Keys verschlüsselt. Außerdem kann man Dateien austauschen und je nach Einstellungen kann jeder Freund oder nur Freunde von Freunden (dass die eigene IP unbekannt bleibt) freigegebene Dateien von dir laden. Wenn man eine Datei über einen Freund tunnelt, wird die Datei mit dem Key von dem Empfänger und dem Sender verschlüsselt –> nur die beiden wissen welche Datei versendet wird.

Höchst warscheinlich hatte sich ein Abmahnanwalt in ein größeres RetroShare Netzwerk eingeschlichen und eine Datei heruntergeladen. Da man den eigentlichen Besitzer nicht finden konne hat man einfach mal den armen Typen, der die Datei getunnelt hat abgemahnt. Wenn man das so sieht, dürfte man auch keinen Tor-Node betreiben oder sogar ISP’s dürften abgemahnt werden. Da das ganze so undurchsichtig ist bin ich mir sicher, dass das Urteil in nächster Instanz aufgehoben werden würde.

Und jetzt noch ein Tipp zu RetroShare: Ich finde man sollte keine Angst haben das ganze zu benutzen. Man muss nur aufpassen, wen man als Freund addet. Wenn man sich aber nur mit Leuten die man kennt vernetzt und das ganze wie ein Web-of-Trust aufzieht (man kann Schlüssel auch unterschreiben), dann ist das ganze eine verdammt sichere Möglichkeit um zu kommunizieren. Mit einem vertrauenswürdigen Freundeskreis ist das ganze wie das Darknet. Man kann dann auch bedenkenlos Dateien austauschen. Solange keine Ratte im Netzwerk ist, braucht man gar nichts befürchten.

Links:
RetroShare Webseite
RetroShare Wikipedia
Web-of-Truse Wikipedia

In der Zeit, in der ich mit Ubuntu gearbeitet habe habe ich mich mit Unity und was Ubuntu halt noch so mit sich bringt angefreundet. Ich fand es gut, da es super für Anfänger geeignet ist und hätte es auch jedem, der sich überlegt umzusteigen empfohlen. Aber dann kam Ubuntu 12.10.

Ich hatte noch nie ein Problem mit Upgrades. Ich hab immer noch eine alte CD (11.04), installiere diese und Upgrade dann auf die neueste Version. Aber das Upgrade von 12.04 LTS auf 12.10 war anders.

Datenträger werden nicht mehr unter /media, sondern unter /media/Benutzername eingehangen. Diese (von Fedora übernommene) Idee, Datenträger immer nur für den entsprechenden Benutzer einzuhängen finde ich an sich nicht schlecht, ABER Ubuntu hat es geschafft, zu vergessen den Ordner zu erstellen, also konnte ich nach dem Update erstmal keine Datenträger einhängen. Für unerfahrenere Benutzer kann das dann schon zu einem Problem werden.

Ein zweiter Punkt, der mich extrem genervt hat, war die fehlende Integration von Pidgin, Thunderbird und anderen Programmen in Unity. Außerdem ist Unity immer mal wieder abgeschmiert.

Da war es für mich dann klar, dass ich mal ein neues Sytem brauche. Ich habe mich für Linux Mint entschieden. Das basiert zwar auch auf Ubuntu, aber es bietet viele verschiedene Desktopumgebungen an. Da habe ich Mate genommen. Ich hatte es erst in einer VM installiert und heute auch auf meinem PC. Bin auf jeden Fall sehr zufrieden mit dem System und weiß was ich ab jetzt Anfängern/Umsteigern empfehlen werde: Auf keinen Fall auf Ubuntu 12.10 upgraden und evtl gleich ein anderes System benutzen.

Leider haben nur 5 Leute aktiv an dem ezine mitgewirkt + ein Interview mit alcopaul. Trotz der geringen Beteiligung sind einige Codes zusammengekommen. Vertreten sind Perl, ASM, C(++), Python und Java. Verglichen mit den alten DarK-CodeZ Mags ist das relativ wenig, aber besser als gar nichts und man kann ja mal hoffen, dass das Interesse am VXing wieder wächst und wir Zuwachs zu vxnet bekommen. Oder evtl sogar neue Gruppen. Wie alcopaul in dem Interview gesagt hatte: eine Gruppe von SPTH und hh86 wäre mega nice.

Jetzt muss ich mir nur noch überlegen, wie ich mein erstes Mag, bei dem ich mitgewirkt habe feiern werde :D

Hier kann man das Mag runterladen und lokal anschauen.

Da Debian 6 nur stable Software über die Paketquellen ausliefert, erhält man via

1

apt-get install openssl

nur die OpenSSL Version 0.9. SPDY benötigt aber Version 1.0.1 oder höher.

Nun hat man 2 Möglichkeiten: entweder, man holt sich den Sourcecode und compiled OpenSSL 1.0.1 manuell, oder man weißst Debian an, neuere Pakete zu benutzen. Zweiteres habe ich gemacht:

Als erstes editiert man die /etc/apt/sources.list mit dem Editor seiner Wahl und fügt irgendwo folgenden Eintrag ein:

1

deb http://ftp.de.debian.org/        testing main contrib non-free

Damit ist es möglich, auch testing Versionen von einer Software herunter zu laden.

Als nächstes erstellt man die Datei /etc/apt/preferences mit folgendem Inhalt:

1
2
3
4
5
6
7

Package: *
Pin: release a=stable
Pin-Priority: 900

Package: *
Pin: release a=testing
Pin-Priority: 400

Nun erstmal ein

1

apt-get update

und gleich dannach

1

apt-get install -t testing openssl

Wenn das abgeschlossen ist, kann man mit

1

openssl version

überprüfen, welche OpenSSL Version installiert ist. Diese sollte jetzt 1.0.1 oder höher sein.

Andere Pakete die noch installiert sein müssen sind

1

build-essential libpcre3-dev libssl-dev libbz2-dev

Jetzt kann man sich den nginx Code runterladen, entpacken, in den entpackten Ordner wechseln und den SPDY Patch runterladen und in den Code Patchen:

1
2

wget http://nginx.org/patches/spdy/patch.spdy.txt
patch -p0 < patch.spdy.txt

Dann nur noch configure ausführen, wobei die Option –with-http_ssl_module unbedingt notwendig ist:

1
2
3

./configure --with-http_ssl_module
make
make install

Und fertig ist nginx.

Jetzt muss nur noch die Config angepasst werden, dass SPDY auch benutzt wird:

1
2
3
4
5
6
7
8

server {
    listen 443 ssl spdy;

    ssl_certificate      server.crt;
    ssl_certificate_key  server.key;

    ...
}

und falls noch nicht geschehen ein Key erzeugt werden:

1
2
3
4
5

openssl genrsa -des3 -out server.key 1024
openssl req -new -key server.key -out server.csr
cp server.key server.key.bak
openssl rsa -in server.key.bak -out serevr.key
openssl x509 -req -days 365 -in server.csr -signkey server.key -out test.in.crt

Eventuell muss in der Config dann noch der Pfad zu den Schlüsseln angepasst werden und dann ist der Server über https zu erreichen und benutzt SPDY.