FRA Challenge 2013 – Pentest

Sec24 – FRA Challenge 2013 – Pentest

Av: Oscar Andersson, Sec24,
Rev 1.0 2013-06-23 Flag01
Rev 1.1 2013-06-27 127.0.0.1.pwdump
Rev 1.2 2013-06-28 Flag09, Flag02, Flag03, Flag06
Rev 1.3 2013-07-22 Flag04, Flag11
Rev 1.4 2013-07-28 Flag10
Rev 1.5 2013-08-02 Flag08

OBS:  Följande guide får enbart användas i utbildningssyfte och absolut inte till olagliga ändamål.

FRA står för Försvarets radioanstalt och beskrivs av Wikipedia enligt följande:

“Försvarets radioanstalt (FRA) är en svensk civil myndighet som sorterar under Försvarsdepartementet. FRA:s två huvuduppgifter är att bedriva signalunderrättelsetjänst (kommunikationsspaning KOS, eng. COMINT resp teknisk signalspaning TES, eng. ELINT) samt stödja informationssäkerhetsarbetet hos myndigheter och statligt ägda bolag. Kommunikationsspaning inriktas mot såväl civil som militär telefoni och datakommunikation. KOS kan delas in i inhämtning, bearbetning (trafikbearbetning inklusive kryptoforcering och innehållsbearbetning), analys och rapportering.”

FRA släpper varje år utmaningar för att testa kunskaper hos potentiella rekryter. Hittas i år på domänen:

http://challenge.fra.se/

I år finns det fyra olika utmaningar, den jag kommer gå igenom är pentest.

Komplett lista:

analytiker-it-sakerhet2013-1.zip

Testa din förmåga att analysera nätverkstrafik.

pcap-challenge2013-1.zip

Testa dina kunskaper i analys av nätverkstrafik.
Målgrupp IT-säkerhetstekniker med inriktning nätverksövervakning och intrångsdetektering.

pentest-challenge2013-1.zip

Vmware virtuell maskin som innehåller diverse sårbarheter, hitta sårbarheterna och ta dig fram till flaggorna för vinst.
Challenge för IT-säkerhetstekniker med inriktning penetrationstestning.

reverse-challenge2013-1.zip

Detta är en reversing utmaning där det gäller för dig att hitta fram till rätt lösenord och sen beskriva hur du gick tillväga och eventuella problem du stötte på.”

FRA gör även reklam som återfinns i bland annat Ny Teknik och Computer Sweden. För något år sedan såg reklamen ut enligt följande:

“zzz.iud.vh/fkdoohqjh

FRA söker it-säkerhetsspecialister med rätt skärpa.

Är du tillräckligt nyfiken?”

Det krävs ingen utbildning inom kryptografi för att förstå att det döljer sig en länk bakom tecknen. Tre stycken zzz på rad antar vi står för www. I alfabetet har Z plats 26 och W plats 23. Det skiljer totalt tre platser och går vi vidare med tecknen får vi snart fram att länken är “www.fra.se/challenge“. Det går att göra manuellt men det går även att skriva ett script.

input = "zzz.iud.vh/fkdoohqjh" # Texten vi vill dekryptera
input = input.lower() # Alla bokstäver konverterats till små. Detta för att stora och små bokstäver har olika värden.
output = [] # Skapar en ny lista som heter output
for character in input: # For loop som går igenom varje tecken i strängen input. 
    number = ord(character) # ord används för att konvertera en sträng till en integer. 
    output.append(number) # append lägger till integers i listan output vi skapade tidigare.
print output # Skriver ut siffrorna vi fått fram. Siffrorna motsvarar bokstävernas ASCII-värden. 
i = 0     	 # Bokstaven a motsvarar värdet 97 tillexempel. 
length = len(output)
while i < length:
  output[i]-=3 # Loopar siffrorna och subtraherar alla med tre. 
  i+=1
print output 
i = 0
length = len(output)
while i < length:
	if output[i] < 96:
		output[i] +=3 # Loopar siffrorna igen och lägger till tre på alla värden som är under 96. 
	i+=1			  # Detta för att punkt och forward slash ej är "krypterade" och kommger visa fel tecken annars. 
print output  
output2 = []
for character in output:
    letter = chr(character) # Skriver om siffrorna till strängar som lagras i den nya listan output2. 
    output2.append(letter)
print output2
output3 = ''.join(output2) # Gör om listan till en sträng som går att läsa lättare. 
print output3

Körs skriptet får vi fram nedanstående. Jag använder mig av Notepad++ med tillägget Python Script. Scriptet går att skriva mycket snyggare men för att förstå varje steg är nedanstående ett av de enklaste sätten.

Sec24 sec 24 hur hackar man FRA challenge 2013 pentest 1

För att återgå till årets utmaning. Starta upp den virtuella maskinen som du laddat ner från FRA (pentest-challenge2013-1.zip).

Enligt beskrivningen så ska du hitta sårbarheter och ta dig fram till flaggorna för vinst. Det första jag gör är att starta upp en ny terminal genom att klicka på skrivbordet -> Gå ner till XShells -> Root Access -> Dark. Jag kör sedan kommandot ls -l för att se vad som finns i rotkatalogen.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag01-flagga-flaggor

Filerna som finns här är: 127.0.0.1.pwdump, collected och katalogen flags. Vi börjar med att navigera till flags genom kommandot cd flags följt av ls -l igen för att se vilka filer som finns. Här finns en fil som heter Readme.pdf. Alltid bra att läsa instruktioner först och under Apps -> Office -> PDF Viewer hittar vi programmet Xpdf. Vi öppnar pdf:en med kommandot xpdf Readme.pdf. Här får vi fram information att: “A flag consists of four letters. Flags are randomly numbered. Decrypt as many files as possible to capture the flags. Good luck!”. Vi vill nu se att det inte finns något gömt i pdf-filen. Det gör vi med kommandot nano Readme.pdf. Går även att öppna med andra textredigerare som finns installerat på den virtuella maskinen såsom Beaver, Notepad eller Vim. I programmet Nano kan du trycka Ctrl + W för att söka efter ord. Testar att söka efter password men får inte fram något. Söker vi däremot efter script så blir det en träff.

Sec24 sec 24 hur hackar man FRA challenge 2013 pentest 3

Skriptet ser ut enligt följande:

chs = “abcdefghijklmnopqrstuvwxyz0123456789″;

ceasar = [3,17,12,18,3,17,12,18,28,29,26,31];

Nu ska vi göra ett eget pythonskript igen. Ett rimligt antagande är att varje siffra i ceasar motsvarar en bokstav. För att få fram ett lösenord kör vi nedanstående script:

chs = "abcdefghijklmnopqrstuvwxyz0123456789"
ceasar = [3,17,12,18,3,17,12,18,28,29,26,31]
password = [] # Skapar en ny tom lista som heter password
for i in ceasar: 
    password += chs[i] # Går igenom ceasar och lägger till bokstaven siffran motsvarar från chs.
password2 = ''.join(password)
print password2

Får du felet “SyntaxError: Non-ASCII character ‘\xc3′” går du upp till format och väljer “Koda i UTF-8″ i Notepad ++. Lösenordet vi får fram är drmsdrms2305. Anledningen till att siffran 3 motsvarar ett d är på grund av att python som de flesta andra programmeringsspråk räknar med siffran 0. Hade det istället stått “ceasar = [0,17,12,18,3,17,12,18,28,29,26,31]” hade koden varit armsdrms2305.

Sec24 sec 24 hur hackar man FRA challenge 2013 pentest 4

Som vi såg innan slutade filändelsen för flaggorna med .gpg. Det står för GNU Privacy Guard och för att låsa upp filen kör vi kommandot gpg Flag01.txt.gpg. Vi skriver sedan in lösenordet och om allt går vägen är filen nu upplåst. Flag01.txt kan sedan öppnas med en textredigerare.

För att se vad root gjort innan vi tog kontrollen går det antingen att läsa filen /root/.bash_history eller köra kommandot history. För att få en bättre överblick startar jag upp en ny VM och kör history som första kommando innan jag kört startx.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-41 Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-42

Vi ser nu att kommandot “/bin/rm -f /root/my-secret-password-file-containing-q51wx23-account.txt” körts. Kommandot har tagit bort filen my-secret-password-file-containing-q51wx23-account.txt. När data tagits bort som du vill återställa ska du genast stänga av datorn. Detta då webbläsares cacheminne och annat kan skriva över data som annars gått att rädda. När VM är avstängd öppnar jag challenge.vmdk (VMDK = Virtual Machine Disk) i HxD som är en Hexredigerare (Hex editor). Efter en sökning på q51wx23 får vi fram tre sökresultat. Det sista innehåller texten: “User: q51wx23 Password: mvOuy3ZzOhMnVce”. Lösenordet mvOuy3ZzOhMnVce låser upp Flag10.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-45

I root-katalogen finns fortfarande två intressanta filer vi inte behandlat, nämligen collected och 127.0.0.1.pwdump. Vi börjar med att köra kommandot file på collected och får då fram att det är en tcpdump fil. Efter att ha kört Tcpdump ser vi att det handlar om ett UDP-protokoll. Kör sedan strings och ser där Linphone som är en VoIP-klient (Voice over Internet Protocol, IP-telefoni) som använder sig av SIP-protokollet. Ser även e-mail adressen ed4fe@pjb6198b.org som vi noterar.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag08-flagga-flaggor-47

Wireshark kan spela upp Voip-konversationer så vi startar upp det. Finns att ladda hem här om du inte har det sedan tidigare. Vi laddar in filen och går sedan till Telephony -> VoIP calls. Efter någon sekund kommer det upp att ett VoIP call har hittats. Markera och tryck sedan på Player följt av Decode i den nya rutan. Markera sedan det översta “klippet” och tryck på play. En röst spelar nu upp lösenordet 7sawk82b3t5df som låser upp Flag08.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag08-flagga-flaggor-48

I root-mappen finns även filen 127.0.0.1.pwdump. Öppnar vi den med en textredigerare får vi fram följande information:

Administrator:500:NO PASSWORD*********************:NO PASSWORD*********************:::
Dom:1003:BA4C3F5D10CD9992BA4C3F5D10CD9992:91DD21C112D58DAA97D004174B5AE277:::
Miles:1005:NO PASSWORD*********************:A4F32255FD6D387DCD9FBC33FE314CFE:::
Nash:1004:NO PASSWORD*********************:68BE26264C74F768DCF7EA928A32E245:::

Informationen ovan är lösenordshashar och de kan identifieras med hjälp av programmet John the Ripper (JTR). Vi startar programmet genom att skriva john och sedan kör vi kommandot ./john /root/127.0.0.1.pwdump. Nu ser vi att filen består av NT och LM hashar. LM hashen knäcks direkt av John men är uppdelad. En LM-hash (LanMan eller LAN Manager hash) användes av nätverksoperativsystemet LAN Manager men har även använts av operativsystemen i Windows NT-familjen. Fram till Windows Vista var protokollet aktiverat som standard. LM-hashar har flera sårbarheter och kan i nuläget knäckas på några få sekunder. Den första svagheten är att lösenorden max får vara 14 tecken långt och är lösenordet längre än sju tecken delas lösenordet upp i två delar som hashas separat. Lösenordet konverteras även automatiskt till versaler (uppercase). Därav ser lösenordet ut enligt nedan. –pot=a.pot la jag till för att visa hur det ser ut första gången John körs mot filen 127.0.0.1.pwdump.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag flags flag02 flagga flaggor 2

För att visa hela lösenordet kör vi kommandot ./john /root/127.0.0.1.pwdump –show 

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag flags flag02 flagga flaggor 3

Vi får nu fram att lösenordet är TORONTOTORONTO. Det vi inte vet är vilka bokstäver som är stora respektive små. För att skapa en lista med alla varianter gör vi ännu ett script. Vi får nu fram att det finns 16384 olika kombinationer det kan vara. Istället för att prova manuellt på alla flaggor skapar vi en lista som vi använder med John för att knäcka NT-hashen.

import itertools
s = 'TORONTOTORONTO'
lista = map(''.join, itertools.product(*zip(s.upper(), s.lower())))
print  "\n".join(lista)

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag flags flag02 flagga flaggor 4

Jag använder mig av John på min distribution av Kali för att knäcka lösenordet. Anledningen till det är att skriptet skrevs på min Windowsdator och jag enklare kunde kopiera över listan till Kali än FRA challenge VM. Vi får fram att lösenordet är tOroNTotOroNTo.

john –format=nt –wordlist=/root/Desktop/torontolist /root/Desktop/127.0.0.1.pwdump

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag flags flag02 flagga flaggor 5

Vi har nu lösenordet för användaren Dom. Nästa steg är att navigera till Doms hemkatalog för att se vad som finns där. Vi hittar där filen network_stuff.zip.bfe. Kommandona vi kör för att hitta dit är:

cd /

ls -l

cd home

ls -l

cd dom

ls -l

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag flags flag02 flagga flaggor 6

Nästa steg är att dekryptera filen. Filändelsen .bfe står för att filen är krypterad med Bcrypt Blowfish. För att dekryptera kör vi kommandot bcrypt network_stuff.zip.bfe och skriver in lösenordet tOroNTotOroNTo. Vi verifierar sedan att filen är dekrypterad genom kommandot ls. Vi ser nu endast filen network_stuff.zip som innebär att filen har dekrypterats.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag flags flag02 flagga flaggor 8

Nästa steg är att unzippa filen. Jag väljer att zippa upp filerna till rootkatalogen och sedan kontrollera att de kommit rätt. Det gör jag med följande kommandon:

unzip network_stuff.zip -d /root

cd /root

ls -l

cd  network_stuff/

ls -l 

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag flags flag02 flagga flaggor 9

Vi börjar med att gå igenom filen imagine.conf med valfri textredigerare. Informationen vi direkt möts av är att dom uppdaterade filen senast den 21 maj 2003. Vi ser även att imagine är ett hostname. Imagine Communications tillverkar bland annat routrar men om vi Googlar “logging buffered” eller “logging console” får vi upp flera resultat från Cisco.”Enable secret 5 $1$Z90l6GX.$1trR36jc96ZVB8sGvufSa/” skulle även det kunna komma från en Cisco router.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag flags flag02 flagga flaggor 10

Längre ner i dokumentet hittar vi något intressant: “password 7 09144B50165520172E18200278″. Password 7 är en dåligt krypterad algoritm som det finns flera sätt att knäcka. Jag använder mig av ett Perl-skript som är lite modifierat.

#!/usr/bin/perl
use File::Copy;
 
############################################################################
# Vigenere translation table
############################################################################
@V=(0x64, 0x73, 0x66, 0x64, 0x3b, 0x6b, 0x66, 0x6f, 0x41, 0x2c, 0x2e,
    0x69, 0x79, 0x65, 0x77, 0x72, 0x6b, 0x6c, 0x64, 0x4a, 0x4b, 0x44,
    0x48, 0x53, 0x55, 0x42, 0x73, 0x67, 0x76, 0x63, 0x61, 0x36, 0x39,
    0x38, 0x33, 0x34, 0x6e, 0x63, 0x78, 0x76, 0x39, 0x38, 0x37, 0x33,
    0x32, 0x35, 0x34, 0x6b, 0x3b, 0x66, 0x67, 0x38, 0x37);
############################################################################
 
############################################################################
# Usage guidelines
############################################################################
if ($ARGV[0] eq ""){
   print "This script reveals the IOS passwords obfuscated using the Vigenere algorithm.n";
   print "n";
   print "Usage guidelines:n";
   print " cdecrypt.pl 04480E051A33490E     # Reveals a single passwordn";
   print " cdecrypt.pl running-config.rcf   # Changes all passwords in a file to cleartextn";
   print "                                  # Original file stored with .bak extensionn";
}
 
############################################################################
# Process arguments and execute
############################################################################
if(open(F,"<$ARGV[0]")){    # If argument passed can be opened then convert a file
  open(FO,">cdcout.rcf") || die("Cannot open 'cdcout.rcf' for writing ($!)n");
  while(<F>){
    if (/(.*passwords)(7s)([0-9a-fA-F]{4,})/){     # Find password commands
      my $d=Decrypt($3);                             # Deobfuscate passwords
      s/(.*passwords)(7s)([0-9a-fA-F]{4,})/$1$d/;  # Remove '7' and add cleartext password
    }
    print FO $_;
  }
  close(F);
  close(FO);
  copy($ARGV[0],"$ARGV[0].bak")||die("Cannot copy '$ARGV[0]' to '$ARGV[0].bak'");
  copy("cdcout.rcf",$ARGV[0])||die("Cannot copy '$ARGV[0]' to '$ARGV[0].bak'");
  unlink "cdcout.rcf";
}else{                      # If argument passed cannot be opened it is a single password
  print Decrypt($ARGV[0]);
}
 
############################################################################
# Vigenere decryption/deobfuscation function
############################################################################
sub Decrypt{
  my $pw=shift(@_);                             # Retrieve input obfuscated password
  my $i=substr($pw,0,2);                        # Initial index into Vigenere translation table
  my $c=2;                                      # Initial pointer
  my $r="";                                     # Variable to hold cleartext password
  while ($c<length($pw)){                       # Process each pair of hex values
    $r.=chr(hex(substr($pw,$c,2))^$V[$i++]);    # Vigenere reverse translation
    $c+=2;                                      # Move pointer to next hex pair
    $i%=53;                                     # Vigenere table wrap around
  }                                             #
  return $r;                                    # Return cleartext password
}

Perl-scriptet kopierar jag till Kalis skrivbord och kör sedan kommandot: perl /root/Desktop/ciscodec.pl 09144B50165520172E18200278

Vi får då fram det dekrypterade lösenordet: 8e9o0WeEtDH3 som låser upp Flag09.txt.gpg.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag flags flag02 flagga flaggor 11

Nästa fil att gå igenom är captured.pcap. Pcap står för packet capture och det är ett API för att fånga nätverkstrafik. Vi börjar med att analysera filen med programmet tcpdump. Tcpdump kan både användas för att logga nätverkstrafik och läsa filerna som skapas. Det vanligaste programmet för att läsa av nätverkskommuikation är annars Wireshark. Kommandot vi kör är: tcpdump -r captured.pcap

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag02-flagga-flaggor-12

Här ser vi bland annat FTP-sessioner som kan vara intressanta. Vi försöker få fram mer information genom att använda stringskommandotstrings captured.pcap ger följande text:

“~220 Microsoft FTP Service
kUSER ariadne
331 Password required for ariadne.
PASS MyS4meOldPwd
230 User logged in.”

Utöver lösenordet för ariadne ser vi även en strängen “R29pbmdTeWRuZXkyTEFYCg==”.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag02-flagga-flaggor-13

Strängen “R29pbmdTeWRuZXkyTEFYCg==” är en så kallad Base64-sträng och kan “dekodas” via programmet base64. Öppna valfri textredigerare och spara enbart strängen “R29pbmdTeWRuZXkyTEFYCg==” i filen. Jag döpte min fil till cap. Navigera sedan till platsen du sparade filen på och kör följande kommando: base64 -d cap. Lösenordet i klartext är GoingSydney2LAX som kan användas för att låsa upp Flag02.txt.gpg. Base64 är ingen kryptering och kräver inte någon speciell datorkraft för att dekoda.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag02-flagga-flaggor-14

Vi har fortfarande kvar ariadnes lösenord så vi navigerar nu till dennes hemkatalog med cd /home/ariadne. Här hittar vi filen images.tar.bfe. Vi låser upp filen med kommandot bcrypt images.tar.bfe och lösenordet MyS4meOldPwd. Jag kopierar sedan images.tar till root-mappen och extraherar filerna med kommandot tar -xvf images.tar och verifierar sedan att filerna packats upp korrekt.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag02-flagga-flaggor-15

Filerna som finns i mappen är: cube.svg, square.png, stairs.jpg och triangle.svg. Ingen av filerna innehåller bildmässigt något konstigt. Kollar vi däremot närmare på headern för stairs.jpg genom kommandot file stairs.jpg så hittar vi något. Texten vi får fram är “VGhlLUhvdXJHMWFTUwo=ÿÛ” och även detta är en base64-sträng. Vi avkodar strängen på samma sätt som förra gången och får då fram lösenordet för Flag03.txt.gpg som är The-HourG1aSS. Visar sig ännu tydligare om vi använder programmet jhead som finns installerat på Linuxmaskinen.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag02-flagga-flaggor-16

 

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag12-flagga-flaggor-60

Något som också drar ögonen till sig är ID:et i triangle.svg som vi får fram genom kommandot strings triangle.svg. Där specificeras att id=’W5M0MpCehiHzreSzNTczkc9d’. Efter att ha försökt knäcka “hashen” i några olika program löser Google snabbt gåtan. Detta kryptiska ID ges av någon anledning till vissa Adobefiler.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag02-flagga-flaggor-17

Nu har vi ingen utlagd väg som tidigare men då de andra nycklarna lett oss till olika användare navigerar vi till /home. ariadne och dom har vi gått igenom och nästa användare är dsl. Dennes mapp är tom och det noterar vi bara för närvarande. Nästa mapp är eames och här finns filen gesture.key. Efter en snabb googling verkar filen vara en upplåsningskod för Android och efter ännu lite sökande hittar jag ett skript på Github som kan knäcka mönstret. Jag kopierar scriptet och gesture.key till Kali och kör sedan kommandot python crack.pattern.py gesture.key. Mönstret som hittas är: 647583210. Provade denna kod flera gånger utan att lyckas och trodde först att koden inte gick till någon flagga utan istället skulle låsa upp andra delar av systemet. Efter att ha studerat mönstret en gång till noterade jag att det inte fanns någon gesture-punkt 0 i figuren samt att mönstret som hittats inte innehöll siffran 9. Jag adderade då +1 till varje nummer och fick fram koden 758694321. Denna kod låste upp Flag06.txt.gpg.

#!/usr/bin/env python
#
#  Copyright (c) 2012, Chema Garcia
#  All rights reserved.
#
#  Redistribution and use in source and binary forms, with or
#  without modification, are permitted provided that the following
#  conditions are met:
#
#     * Redistributions of source code must retain the above
#       copyright notice, this list of conditions and the following
#       disclaimer.
#
#     * Redistributions in binary form must reproduce the above
#       copyright notice, this list of conditions and the following
#       disclaimer in the documentation and/or other materials provided
#       with the distribution.
#
#     * Neither the name of the SafetyBits nor the names of its contributors may
#       be used to endorse or promote products derived from this software
#       without specific prior written permission.
#
#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
#  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
#  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
#  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
#  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
#  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
#  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
#  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
#  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
#  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
#  POSSIBILITY OF SUCH DAMAGE.
#
# Author: Chema Garcia
# Date: 08/2012
# Homepage: Http://safetybits.net
# Email: chema@safetybits.net
# Twitter: @sch3m4
#

import os
import sys
import binascii

try:
    import hashlib
    import itertools
except ImportError, ie:
    print "[e] %s" % ie
    sys.exit(-1)


MIN_PATTERN = 3  # Min. pattern length
MAX_PATTERN = 9  # Max. pattern length


def crack_pattern(sha1sum):
    """
    http://forensics.spreitzenbarth.de/2012/02/28/cracking-the-pattern-lock-on-android/

    Java Source:
    ------------
    private static byte[] patternToHash(List pattern) {
        if (pattern == null) {
            return null;
        }

        final int patternSize = pattern.size();
        byte[] res = new byte[patternSize];
        for (int i = 0; i < patternSize; i++) {
            LockPatternView.Cell cell = pattern.get(i);
            res[i] = (byte) (cell.getRow() * 3 + cell.getColumn());
        }
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-1");
            byte[] hash = md.digest(res);
            return hash;
        } catch (NoSuchAlgorithmException nsa) {
            return res;
        }
    }
    """

    # for each length
    for i in range(MIN_PATTERN, MAX_PATTERN + 1):
        print '[+] Checking length %d' % i
        # get all possible permutations
        perms = itertools.permutations([0, 1, 2, 3, 4, 5, 6, 7, 8], i)
        # for each permutation
        for item in perms:
            # build the pattern string
            pattern = ''.join(str(v) for v in item)
            # convert the pattern to hex (so the string '123' becomes '\x01\x02\x03')
            key = binascii.unhexlify(''.join('%02x' % (ord(c) - ord('0')) for c in pattern))
            # compute the hash for that key
            sha1 = hashlib.sha1(key).hexdigest()

            # pattern found
            if sha1 == sha1sum:
                return pattern

    # pattern not found
    return None


def show_pattern(pattern):
    """
    Shows the pattern "graphically"
    """

    gesture = [None, None, None, None, None, None, None, None, None]

    cont = 1
    for i in pattern:
        gesture[int(i)] = cont
        cont += 1

    print "[+] Gesture:\n"

    for i in range(0, 3):
        val = [None, None, None]
        for j in range(0, 3):
            val[j] = " " if gesture[i * 3 + j] is None else '\033[94m' + str(gesture[i * 3 + j]) + '\033[0m'

        print '  -----  -----  -----'
        print '  | %s |  | %s |  | %s |  ' % (val[0], val[1], val[2])
        print '  -----  -----  -----'


if __name__ == "__main__":

    print ''
    print '################################'
    print '# Android Pattern Lock Cracker #'
    print '#             v0.1             #'
    print '# ---------------------------- #'
    print '#  Written by Chema Garcia     #'
    print '#     http://safetybits.net    #'
    print '#     chema@safetybits.net     #'
    print '#          @sch3m4             #'
    print '################################\n'

    print '[i] Taken from: http://forensics.spreitzenbarth.de/2012/02/28/cracking-the-pattern-lock-on-android/\n'

    # check parameters
    if len(sys.argv) != 2:
        print '[+] Usage: %s /path/to/gesture.key\n' % sys.argv[0]
        sys.exit(0)

    # check gesture.key file
    if not os.path.isfile(sys.argv[1]):
        print "[e] Cannot access to %s file\n" % sys.argv[1]
        sys.exit(-1)

    # load SHA1 hash from file
    f = open(sys.argv[1], 'rb')
    gest = f.read(hashlib.sha1().digest_size).encode('hex')
    f.close()

    # check hash length
    if len(gest) / 2 != hashlib.sha1().digest_size:
        print "[e] Invalid gesture file?\n"
        sys.exit(-2)

    # try to crack the pattern
    pattern = crack_pattern(gest)
    print ''

    if pattern is None:
        print "[:(] The pattern was not found..."
    else:
        print "[:D] The pattern has been FOUND!!! => %s\n" % pattern
        show_pattern(pattern)

    print ''
    sys.exit(0)

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-18

Nästa användare är mal och i dennes katalog hittar vi filen “crackme”. Kör vi kommandot file crackme ser vi att det är en ELF-fil. ELF står för Executable and Linkable Format och är en så kallad exekverbar fil.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-19

Provar vi att exekvera filen med kommandot ./crackme får vi upp “Type the correct password:”. Provar valfritt lösenord och programmet returnerar då “Wrong Password!”, förmodligen.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-20

För att förstå vad programmet gör öppnar vi filen i IDA Pro som är en disassembler. En disassembler är programvara som som analyserar en kompilerad fil och reproducerar källkoden för filen i assemblerkod. En gratisversion av IDA Pro finns att ladda ner till Windows här. För att få bättre förståelse för Intels X86 arkitektur kan ni läsa mer om det i guiden “Introduktion till Intel X86“. När vi först öppnar upp filen möts vi av två strängar innan “Type the correct password:”. Strängarna är thiswaseasy och ZKFQKT. Provar att skriva båda som lösenord för crackme men de fungerar inte utan programmet returnerar fortfarande “Wrong password!”.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-21

Efter att ha analyserat koden och sett var minnesadressen [ebp+var_2C] från “thiswaseasy” används hittar vi något intressant. Fastnar framförallt för xor, “xor al, [esi+ebx]”, då det används för lättare kryptering i program (xor reg, reg används ofta för att sätta ett värde till 0, exempelvis “int i=0″, och ska inte förväxlas med kryptering). När xor däremot hämtar något ur minne som i detta fallet är det något helt annorlunda. Se exempel nedan:

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-23

Ovanför xor… och movzx… hittar vi “mov eax, [ebp+var_2C]”. [ebp+var_2C] är minnesadressen där “thiswaseasy” sparades. eax är som bekant Extended Accumulator register och ax var ett av de första registren för generella ändamål när Intel x86 enbart stödde 16-bitar. Det går även att komma åt ah och al (High och low byte). När xor al, [esi+ebx] körs är det accumulator register, low byte som används. XOR är en symmetrisk rutin och det innebär att samma nyckel som används för att kryptera data kan även dekryptera data. Det går att kryptera en byte i taget med en fast nyckel (Exempelvis: 0xAB) men det vanligaste är 4-bytes xor. För 1-byte kryptering skulle det kunna stå xor al, 0ABh och för 4-bytes xor eax, 049171661h. I vårt fall är det ingen fast nyckel utan istället så kallat rullande xor (rolling xor). Här användes en följd av olika bytes för att kryptera strängen.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-24Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-22

Vi går nu tillbaka och kollar på strängen efter “thiswaseasy” som vid det här laget känns som den krypterade strängen.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-25

Vi ser hexkoden på bilden ovan men för att få en tydligare bild använder jag mig av ren hex-view (View -> Open subviews -> Hex dump). Vi ser nu att thiswaseasy består av bytesen: “74 68 69 73 77 61 73 65  61 73 79 00″. 00 är null-tecknet () som visar att strängen tagit slut.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-26

Mellan thiswaseasy och “Type the correct password:” har vi vår krypterade data. Det är 20 00 5A 4B 46 51 4B 54 12 10 49 19  49 07 14 00 och vi tar som vanligt bort den sista 00:an då denna representerar null-tecknet.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-27

För att dekryptera datan använder jag modifierad kod från scriptet xortools.py, rolling_xor.

#!/usr/bin/python
import struct

def single_byte_xor(buf, key):
    out = ''
    for i in buf:
        out += chr(ord(i) ^ key)
    return out

def single_byte_brute_xor(buf, plntxt, start=None, end=None):
    for key in range (1,255):
        out = ''
        for i in buf:
            out += chr(ord(i) ^ key)
        for p in plntxt:
            if out[start:end].find(p) != -1:
                return (p, key, out)
    return (None,None,None)

def get_xor_permutations(buf):
    out = []
    for key in range(1,255):
        out.append(single_byte_xor(buf, key))
    return out

def four_byte_xor(buf, key):
    out = ''
    for i in range(0,len(buf)/4):
        c = struct.unpack("=I", buf[(i*4):(i*4)+4])[0]
        c ^= key
        out += struct.pack("=I", c)
    return out

def rolling_xor(buf, key):
    out = ''
    k = 0
    for i in buf:
        if k == len(key):
            k = 0
        out += chr(ord(i) ^ ord(key[k]))
        k += 1
    return out

def yaratize(rule, vals):
    n = 0
    strs = []
    for val in vals:
        s = '    $_%d = { ' % n
        for c in val:
            s += "%2.2x " % ord(c)
        s += '}'
        strs.append(s)
        n += 1
    return """
rule %s
{
    strings:
%s

    condition:
    any of them
}""" % (rule,'\n'.join(strs))

Den färdiga koden ser ut enligt följande och ger lösenordet “Th381081sc0m!ng”:

key = "thiswaseasy"
buf = "\x20\x00\x5a\x4b\x46\x51\x4b\x54\x12\x10\x49\x19\x49\x07\x14"
out = ''
k = 0
for i in buf:
    if k == len(key):
        k = 0
    out += chr(ord(i) ^ ord(key[k]))
    k += 1
print out

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-28

Testar vi lösenordet i programmet får vi fram strängen “Correct password… Maybe use this somewhere else? ;)” och mycket riktigt går det att låsa upp Flag04 med lösenordet: Th381081sc0m!ng

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-29

Användaren roberts hemkatalog är också tom, det noterar vi, och går vidare till saito. I saitos katalog finns det en cookie. Vi öppnar denna i Notepad för att se vad den innehåller.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-30

Förutom paradox.local finns även domänen dreams.local.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-31

Under Tools har vi något som heter Cookie Editor. Här finns för närvarande ingen cookie så vi försöker logga in med valfria uppgifter för att skapa en cookie.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-32

Efter att ha försökt logga in med fel uppgifter har vi nu en cookie som vi kan modifiera. Vi öppnar cookie editor igen och klickar på Edit. På raden “Content” tar vi bort det befintliga innehållet och lägger in informationen från cookien i saitos hemkatalog.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-33

Sparar informationen genom att klicka på Save och laddar sedan om sidan dreams.local. Vi är nu inloggade som Mr. Saito och klickar vi på “May the force be with you, always!” (SWTOR = Star Wars: The Old Republic) får vi fram lösenordet LifeIsButAdrEAM4M3 som låser upp Flag11.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-34

Med tanke på att det finns en inloggningsskärm så borde det leda till en databas. Gör en sökning i hela systemet efter “dreams” med kommandot “find . -name dreams\*“. Får fram /opt/apache/2.2.22/dreams som en intressant mapp. I mappen finns filerna index.php och style.css men även support.js och swtor.db. Här är databasen vi letat efter.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-35

Efter att ha kört en strings på filen swtor.db får vi fram att det är en SQLite format 3 databas. Vi ser även tabellerna alter_egos och users. Användaren saito syns på flera ställen men även Dom har ett konto. Tittar vi på konfigurationsfilen för apache i opt/apache/version/httpd.conf ser vi även att ServerAdmin är dom@paradox.local. Tidigare såg vi att lösenordet för användaren Dom var tOroNTotOroNTo så jag testade att logga in med det lösenordet, dock utan att lyckas.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag06-flagga-flaggor-36

Då det är en SQLite-databas kör vi kommandot sqlite swtor.db följt av select * from users; och select * from alter egos; för att försöka få mer information. Vi ser nu klart och tydligt att informationen i users är krypterad. För att kontrollera att det inte finns fler tables i databasen kör vi kommandot .tables.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag08-flagga-flaggor-50

Vi går nu vidare och kontrollerar filerna index.php och support.js. I index.php ser vi inloggningen och anropen som görs till databasen. Vi ser även att när användaren skrivit sitt användarnamn och lösenord så körs funktionen “calcResponse” i support.js. Innan vi kontrollerar javascriptet så ser vi funktionen “mcrypt_create_iv_with_srand” som sedan skrivs till parametern “challenge”. Challenge är ett gömt fält men som trots allt skrivs ut i källkoden på sidan tack vare “php print“. Exempel från Firefox (Bon Echo) “View Page Source” nedan. Challenge är där: “F0Y,9[.1$;^Pw,d”.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag08-flagga-flaggor-51

mcrypt

I funktionen “challenge = mcrypt_create_iv_with_srand(15)” ser vi att challenge alltid är 15-tecken långt. Vi kan även se hur den beräknas och hur det går att modifiera den. Mer om det lite senare.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag08-flagga-flaggor-52

Vi går nu över till support.js som FRA beskriver med egna ord:


// Our own L33t Haxx00r hash algorithm.
// No1 will eveer crack this one…”

Här ser vi funktionen calcResponse som tar in user, pwd (password) samt challenge och returnerar efter det response.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag08-flagga-flaggor-53

För att lättare kunna modifiera koden kommer vi kopiera filerna över till Kali och fortsätta där men innan vi gör det vill vi ha lite mer info om servern. Phpinfo ger oss all information vi behöver om PHP-konfigurationen och för att veta vilka tillägg som kommer krävas. Vi såg sedan tidigare SQLite3 och mcrypt men det är trots allt bra att kolla. Vi byter nu directory till  /opt/apache/2.2.22/htdocs och skapar en ny fil med kommandot nano index.php. Vi skriver där in koden nedan och sparar. För att se resultatet är det bara att öppna upp Firefox och sedan lägga till /index.php.

<?php
echo phpinfo();
?>

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag08-flagga-flaggor-54

För att kopiera över filerna tar vi hela FRA challenges .vmdk-fil, kopierar denne och lägger till den som en extra hårddisk för Kali. När hårddisken är tillagd i Kali lägger vi in filerna från /opt/apache/2.2.22/dreams i /var/www. För att få rätt på vilka dependencies som krävdes fick jag Googla runt men i slutändan blev det nedanstående. Vissa finns i Kali från grunden men om ni använder något annat operativsystem är det inte säkert de finns som standard.

sudo apt-get install aptitude

sudo aptitude install apache2 php5 php5-sqlite

sudo apt-get install sqlite3 libsqlite3-dev

sudo apt-get install php5-mcrypt

service apache2 restart

Om allt gått vägen borde följande ruta komma upp i Kali när du skriver in “http://127.0.1.1/index.php” som URL i webbläsaren.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag08-flagga-flaggor-55

Provar vi att logga in händer dock ingenting. Om vi försöker kontrollera cookies förstår vi varför, det finns inga. Nu måste vi modifiera index.php. För att redigera text använder jag antingen vim eller gedit. Vim finns förinstallerat och konfigurationen jag använder är:

set compatible
syntax on
set background=dark
Vim jumps to the last position when reopening a file
filetype indent plugin on
set showcmd
set showmatch
set ignorecase
set smartcase
set incsearch
set autowrite
set hidden
set mouse=a

I Kali finns vimrc i mappen /etc/vim.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag08-flagga-flaggor-56

Gedit är den officiella textredigeraren för Gnome men finns inte förinstallerat på Kali. Laddas hem genom att köra kommandot apt-get install gedit.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag08-flagga-flaggor-57

I index.php söker vi nu efter cookie i VIM genom att skriva /cookie och går vidare till nästa resultat genom att trycka n (N för att gå bakåt). När vi ser funktionen setcookie ser vi att Expire är satt till den 1a april 2013 i originalfilen. På grund av detta sparas inte cookien. Domain är även satt till dreams.local och även headern nedan likaså. Vi modifierar cookien att gå ut 2014 istället och byter ut dreams.local mot 127.0.1.1 (myhostname). Vi byter även sökväg för databasen längre ner i filen “($db = new SQLite3(‘/var/www/swtor.db‘, SQLITE3_OPEN_READWRITE)”.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag08-flagga-flaggor-58

Efter dessa modifieringar kan vi nu använda hemsidan på samma sätt som på Challenges-maskinen men med bättre programvara för att analysera resultatet.

Sec24-sec-24-hur-hackar-man-FRA-challenge-2013-pentest-flag-flags-flag08-flagga-flaggor-59