GreatFET One – HandsOn

Vandaag gaan we het hebben over een relatief nieuw hardware hacking device, de GreatFET One van Great Scott Gadgets. De GreatFET One lijkt in eerste instantie een klein beetje op een Arduino maar is zoveel meer. De GreatFET One is universeel en kan uitgebreid worden voor nog meer mogelijkheden. Op dit moment weet je waarschijnlijk nog steeds niet wat de GreatFET One is. Lees even met me mee en dan zal het allemaal een stuk duidelijker worden. In deze algemene overview vertel ik je alles.

De GreatFET One volgt qua naamgeving de lijn van alle Great Scott Gadgets producten. Denk aan de HackRF One en de Unbertooth One. De GreatFET One gaat schuil onder de codenaam “Azalea” en is de opvolger van de GoodFET. De GoodFET is en open-source JTAG adapter welke op zijn beurt weer geinspireerd is op de TI MSP430 FET UIF en EZ430U boards maar ook op HackADay’s Bus Pirate board waarmee het een universele USB interface is. De GreatFET One is ook een universele USB interface wat feitelijk betekend dat je hem zelf volledig naar wens kunt programmeren zoals een externe chip, een logic analyzer, een debugger, of gewoon heel veel (100) pinnen om te “bit-bangen”, De GreatFET One is voorzien van Hi-Speed USB en een Python API waarmee de GreatFET One geprogrammeerd kan worden. Verder bestaat de GreatFET One uit:

• LPC4330 microcontroller (U1)
• Hi-Speed USB port (USB0) voor connectie met de host controller
• Expansion interface (J1 and J2) van 80 pins (2 female headers verdeeld over 2 dubbele rijen van 20 pins)
• Extra rij met 20 male pins (J7)
• 4 indicator LEDs
• 2 buttons, DFU and RESET, net als de HackRF One welke bedoeld zijn voor development doeleinden
• Full Speed USB port (USB1) voor verbinding naar de target (Facedancer)
• Power switching op USB1 (als host of device)
• Real Time Clock (crystal)
• 3.3 V regulator welke bedoeld is om de zogenaamde “neighbors” van power te voorzien
• 2 MB flash memory
• Unpopulated Cortex Debug Header (J5) for JTAG or SWD
• USB Bootloader in ROM (geen externe hardware nodig om de firmware te uploaden)

In bovenstaande opsomming zien we dat de GreatFET One voorzien is van een groot aantal pinnen. De pin layout is als volgt. Let op, mits anders vermeld zijn alle pinnen op de extention ports 3.3V.

Net als de GoodFET is de GreatFET One zelf samen te stellen en te solderen. Het is een open-source project dus alle onderdelen zijn gemakkelijk verkrijgbaar en de hardware ontwerpen zijn beschikbaar. Toch is de GreatFET One lastiger om zelf te assembleren en ik raad aan om 60-80 euro uit te geven voor een originele GreatFET One zodat je zeker weet dat alle functionaliteiten goed werken.

In bovenstaande opsomming noemde we het al even. De GreatFET One kan voorzien worden van stapelbare uitbreidings boards. Deze extentions noemen we “neighbors”. Een neighbor werkt samen met de GreatFET One maar is gemaakt voor een specifiek doel. Denk aan een speciaal IR (infrarood) board (Gladiolus), een breakout board (Orchid) of een battery power pack (Jasmine). Zoals je ziet hebben alle neighbors een bloemennaam. Neighbors zijn stapelbaar. Er kunnen dus meerdere neighbors “ op elkaar gestapeld” worden om zo samen te werken.

De GreatFET One ondersteund “FaceDancer 2+”. FaceDancer-kaarten zijn eenvoudige hardwareapparaten die werken als remote controlled USB-controllers. Met de juiste software kun je deze kaarten gebruiken om snel en eenvoudig USB-apparaten te emuleren – en om USB-hostcontrollers te fuzzen! Met de FaceDancer 2+ software kunnen vrij gemakkelijk emulaties van USB-apparaten gemaakt worden in Python. De compatibiliteit met FaceDancer zorgt er uiteraard voor dat de mogelijkheden van de GreatFET One ontzettend divers zijn. Zo kan de GreatFET One gebruikt worde nals man-in-the-middle device en kun je dus on the fly USB pakketten modificeren en creeren. Dit is ontzettend handig voor situaties waarbij je zelf niet de software op het USB apparaat kunt beheren zoals bij embedded systems.

GreatFET One Installeren

Laten we eens kijken hoe we het e.e.a. moeten aansturen. We beginnen met de installatie van de GreatFET One en gaan daarna meteen door met de FaceDancer software. De installatie moet gebeuren op een Linux machine. Windows wordt (nog) niet ondersteund.

Het is zaak om eerst Python3 te installeren en om ook de Python Installer Module (PIP) te installeren. De GreatFET One software wordt vervolgens geinstalleerd met het volgende commando:

sudo pip3 install --upgrade greatfet

Om de GreatFET One ook als non-root user te gebruiken moet je de UDEV rules geinstalleerd worden. In dit voorbeeld gaan we ervan uit dat de gebruiker lid is van de “plugdev” groep. Als dat niet zo is kun je de gebruiker hieraan toevoegen of de regel in “/etc/udev/rules.d” veranderen naar een andere groep.

sudo git clone https://github.com/greatscottgadgets/greatfet.gitsudo cp greatfet/host/misc/54-greatfet.rules /etc/udev/rules.dsudo udevadm control --reload-rules

Laten we onze user (master) toevoegen aan de groep, en dit vervolgens controleren.

sudo usermod -a -G plugdev master 
 
grep 'plugdev' /etc/group

Done. Nu zijn we eigenlijk al klaar om de GreatFET aan te sluiten. Maar voor we dat gaan doen gaan we de FaceDancer software installeren. Dit is zo simpel als het clonen van de repository in de gewenste folder:

git clone https://github.com/usb-tools/Facedancer.git

Omdat FaceDancer “gokt” op basis van aangesloten apparaten welk apparaat aangesloten is kun je het beste het gewenste apparaat “hard” instellen. Dit doen we in de “BACKEND” variabele.

export BACKEND=greatfet

Nu zijn we helemaal klaar om de GreatFET One aan te sluiten.

GreatFET One aansluiten en testen

Het aansluiten van de GreatFET One is simpel. De GreatFET One kent 2 USB poorten, een USB0 en een USB1. De USB0 wordt verbonden met de host computer (de computer die de GreatFET installeerd) en de USB1 kant wordt verbonven met het target USB apparaat.

Als je de GreatFET One aangelosten hebt en kun je de status controleren met het volgende commando:

greatfet info

Hoewel alle GreatFET commando’s beginnen met “ greatfet” zullen we v.a. nu de afkorting “gf” gebruiken. Bijde commando’s functioneren hetzelfde. Nu we weten dat de GreatFET goed verbonden is gaan we de firmware up-to-date maken. Zoals je in voorgaande screenshot kon zien werken we met versie “2018.12.1”. Bij de GreatFET is het belangrijk dat de firware versie matched met de geinstalleerde software. Als deze afwijken dan kan het zijn dat de GreatFET niet goed functioneerd. Gelukkis is er een commando welke de firmware naar de juiste versie brengt en dat is:

gf fw --auto

Zoals je ziet is de GreatFET nu up to date (git-2019.5.1.dev0).

En nu alles up-to-date is gaan we onze eerste test uitvoeren. De “hello-world” van het “hardware hacken” namelijk een LED laten knipperen. De GreatFET One heeft 4 verschillende LED’s. LED1 is de “heartbeat” LED welke knippert als het apparaat aan staat. Maar LED2, 3 en 4 kunnen we naar hartelust gebruiken en programmeren. We gaan LED2 laan en weer uitzetten. En dit doen we middels een interactieve GreatFET Python Shell. Deze starten we als volgt:

gf shell

Nu gaan we een variabele aanmaken welke we toewijzen aan LED2 en vervolgens gebruiken we het “toggle” commando om LED2 aan te zetten. Nogmaals het “toggle” commando uitvoeren zorgt er uiteraard voor dat LED2 weer uit gaat.

led2 = gf.leds[2] 
 
led.toggle()

Omdat we werken met Python kunnen we natuurlijk ook de kracht van Python gebruiken om een loopje te maken en LED2 te laten knipperen.

import time 
for i in range(10): 
    gf.leds[3].toggle() 
    time.sleep(0.2)

Meer hulp nodig? Dat kan. Laten we meer hulp opvragen over het LED commando:

help(gf.leds[1])

Spelen met de GreatFET One

Laten we nog eens wat GreatFET commando’s bekijken zodat we pas echt aan de slag kunnen.

Kijk eens goed naar de GPIO (General Purpose Input / Output pins). aanduidingen op je GreatFET One board. Dan zul je zien dat de onderste rij pinnen de “J1” ofwel “Neighbor1” rij is. De bovenste rij is de “J2 / Neighbor2” rij en de bovenste rij met “male” pinnen is de “J7 / Bonus Row” rij. Verder beschikt de GreatFET One nog over een J5 ofwel JTAG (Cortex Debug) rij. Alle rijen worden geteld van linksonder naar rechtsboven. Dus linksonder is pin1, daarboven pin2, daarnaast pin4 en daaronder pin3. Etc. Alle I/O pinnen zijn 3.3V met uitzondering van pin J2 Pin2. Dit is een 5V Pin. De ground pinnen zijn te vinden op de eerste pinnenm dus:

J1-1
J2-1
J7-1
J7-19

Nog een aantal andere speciale pinnen zijn:

J1-2 = VCC (3.3V)
J1-11 = Clock pin (CLK0 en CLK1)
J1-10 = Boot Mode – Pull Up
J1-12 = Boot Mode – Pull Down
J2-2 = VCC (5V)
J2-5 = ADC0_0
J2-13 = DFU, Boot Mode – Pull Down
J2-14 = ISP – Boot Mode – Pull Up
J2-17 = WakeUp0 – Pull Up
J2-35 = Neighbor WC
J2-39 = I2C0_SDA – Pull Up
J2-40 = I2C0_SCL – Pull Up
J7-4 = ADC0_5/ADC1_5
J7-5 = ADC0_2/ADC1_2
J7-6 = Boot Mode – Pull Down
J7-9 = RTC_ALARM
J7-10 = RTCX1
J7-11 = RESET – Pull Up
J7-12 = VBAT
J7-20 = VCC (3.3V)

Pin J1-3 is echter een normale IO pin welke we zonder problemen kunnen programmeren. Het toewijzen aan een variabele doen we als volgt:

pinj1-3 = gf.gpio.get_pin('J1_P3')

Nu kunnen we middels de toegewezen variabele de pin configureren als een normale input of output pin:

pinj1-3.set_direction(gf.gpio.DIRECTION_IN 
 
pinj1-3.set_direction(gf.gpio.DIRECTION_OUT

Om nu de pin in te schakelen gebruiken we:

pinj1-3.write(True)

En om uit te schakelen:

pinj1-3.write(False)

Om een inputpin uit te lezen (staat er wel of geen signaal / voltage op) gebruiken we het “read” commando:

Pinj1-3.read()

GreatFET One FaceDancer

Nu we de basis kennen zouden we b.v. FaceDancer kunnen gebruiken om het e.e.a. te automatiseren middels de FaceDancer scripts. Zo kunnen we de GreatFET One gebruiken als man-in-the-middle om zo alle data tussen de 2 apparaten (host en target) uit te lezen.

Eerst is het goed om te weten dat het GreatFET Communications Protocol een eenvoudig Class / Verb-schema gebruikt om protocol onafhankelijke commando’s te organiseren. Deze kennis heb je niet nodig om simpelweg de FaceDancer programma’s aan te roepen maar wel om ze te schrijven of modificeren.

Classes beheren groepen met verwante functies, terwijl Verbs de functies zelf bieden.

Voorbeelden van Classes:

• SPI-functionaliteit
• FaceDancer (“GreatDancer”) -functionaliteit
• Debug-hulpprogramma’s
• GPIO functies

Voorbeelden van Verbs:

• Configureer de SPI-bus om b.v. de polariteit te regelen
• lezen van het USB1-statusregister (Nodig voor de FaceDancer-host)
• Retourneer de inhoud van de debugring van het apparaat
• Stel een bepaalde GPIO pin in op een bepaalde waarde

Elke Class wordt geïdentificeerd door een unieke 32-bits integer. Elk Verb wordt geïdentificeerd door een 32-bits geheel integer met een unieke naam. Om een klasse toe te voegen aan de GreatFET One moet eerst het nummer gereserveerd worden in het GreatFET One Class Registry:

Om b.v. de GreatFET One een “USB Mass Storage Device” te maken en om vervolgens alles te zien wat er gebeurt tijdens het lezen en schrijven naar het apparaat kunnen we het FaceDancer script “umass” gebruiken. Dit ziet er dan als volgt uit:

python facedancer-umass.py /home/master/Desktop/kali-linux-2019.2-amd64.iso

Conclusie

De GreatFET One is een apparaat zoals we die nog niet eerder gezien hebben. Hij lijkt op een Arduino (en kan ook zo gebruikt worden) maar gebruikt de processorkracht op de eigen computer. Daarnaast lijkt de GreatFET One echt tot zijn recht te komen tijdens USB Hacking waarbij hij als man-in-the-middle kan fungeren. Ik ben heel benieuwd hoe de GreatFET One me gaat helpen om PA/PI / SCADA devices uit te lezen en hoe ik er een goede logic analyzer van kan maken. Deze projecten staan zeker nog op de planning en gaan jullie absoluut hier lezen. Voor nu hoop ik dat je zelf enthausiast geworden bent over de GreatFET One en hier zlef mee aan de slag kunt.

Vond je dit een leuke post laat het me dan even weten met een berichtje, like of share op je eigen website of social media kanaal! Heel erg bedankt!