Rhinoceros inside a cat – spusťte firmware v emulátoru Kopycat

V rámci setkání 0x0A DC7831 DEF CON Nižnij Novgorod 16. února jsme představili zprávu o základních principech emulace binárního kódu a vlastním vývoji - emulátor hardwarové platformy Imitátor.

V tomto článku popíšeme, jak spustit firmware zařízení v emulátoru, předvedeme interakci s debuggerem a provedeme malou dynamickou analýzu firmwaru.

pravěk

Kdysi dávno v galaxii daleko

Před několika lety byla v naší laboratoři potřeba prozkoumat firmware zařízení. Firmware byl komprimován a rozbalen pomocí bootloaderu. Udělal to velmi komplikovaným způsobem a několikrát posunul data v paměti. A samotný firmware pak aktivně interagoval s periferiemi. A to vše na jádře MIPS.

Dostupné emulátory nám z objektivních důvodů nevyhovovaly, přesto jsme chtěli kód spustit. Pak jsme se rozhodli udělat si vlastní emulátor, který by udělal minimum a umožnil nám rozbalit hlavní firmware. Zkusili jsme to a vyšlo to. Přemýšleli jsme, co kdybychom přidali periferie, aby také fungovaly hlavní firmware. Moc to nebolelo - a taky to šlo. Znovu jsme se zamysleli a rozhodli jsme se udělat plnohodnotný emulátor.

Výsledkem byl emulátor počítačových systémů Imitátor.

Proč Kopycat?

Je tam hra se slovy.

1. imitátor (anglicky, noun [ˈkɒpɪkæt]) - imitátor, imitátor
2. kočka (anglicky, podstatné jméno [ˈkæt]) - kočka, kočka - oblíbené zvíře jednoho z tvůrců projektu
3. Písmeno „K“ pochází z programovacího jazyka Kotlin

Imitátor

Při vytváření emulátoru byly stanoveny velmi konkrétní cíle:

• schopnost rychle vytvářet nové periferie, moduly, procesorová jádra;
• schopnost sestavit virtuální zařízení z různých modulů;
• možnost načíst jakákoli binární data (firmware) do paměti virtuálního zařízení;
• schopnost pracovat se snímky (snímky stavu systému);
• schopnost interakce s emulátorem prostřednictvím vestavěného debuggeru;
• pěkný moderní jazyk pro rozvoj.

V důsledku toho byl pro implementaci vybrán Kotlin, architektura sběrnice (to je, když moduly mezi sebou komunikují prostřednictvím virtuálních datových sběrnic), JSON jako formát popisu zařízení a GDB RSP jako protokol pro interakci s debuggerem.

Vývoj probíhá něco málo přes dva roky a aktivně pokračuje. Během této doby byla implementována procesorová jádra MIPS, x86, V850ES, ARM a PowerPC.

Projekt se rozrůstá a je na čase jej představit širší veřejnosti. Podrobný popis projektu uděláme později, ale zatím se zaměříme na používání Kopycatu.

Pro ty nejnetrpělivější je ke stažení promo verze emulátoru odkaz.

Rhino v emulátoru

Připomeňme, že dříve pro konferenci SMARTRHINO-2018 bylo vytvořeno testovací zařízení „Rhinoceros“ pro výuku dovedností reverzního inženýrství. Proces statické analýzy firmwaru byl popsán v tento článek.

Nyní zkusme přidat „reproduktory“ a spustit firmware v emulátoru.

Potřebujeme:
1) Java 1.8
2) Python a modul jep používat Python uvnitř emulátoru. Můžete sestavit modul WHL Jep pro Windows stáhnout zde.

Pro Windows:
1) com0com
2) PuTTY

Pro Linux:
1) socat

Jako klienta GDB můžete použít Eclipse, IDA Pro nebo radare2.

Jak to funguje?

Aby bylo možné provést firmware v emulátoru, je nutné „sestavit“ virtuální zařízení, které je obdobou skutečného zařízení.

Skutečné zařízení („nosorožec“) lze zobrazit v blokovém schématu:

Emulátor má modulární strukturu a finální virtuální zařízení lze popsat v souboru JSON.

JSON 105 řádků

{
  "top": true,

  // Plugin name should be the same as file name (or full path from library start)
  "plugin": "rhino",

  // Directory where plugin places
  "library": "user",

  // Plugin parameters (constructor parameters if jar-plugin version)
  "params": [
    { "name": "tty_dbg", "type": "String"},
    { "name": "tty_bt", "type": "String"},
    { "name": "firmware", "type": "String", "default": "NUL"}
  ],

  // Plugin outer ports
  "ports": [  ],

  // Plugin internal buses
  "buses": [
    { "name": "mem", "size": "BUS30" },
    { "name": "nand", "size": "4" },
    { "name": "gpio", "size": "BUS32" }
  ],

  // Plugin internal components
  "modules": [
    {
      "name": "u1_stm32",
      "plugin": "STM32F042",
      "library": "mcu",
      "params": {
        "firmware:String": "params.firmware"
      }
    },
    {
      "name": "usart_debug",
      "plugin": "UartSerialTerminal",
      "library": "terminals",
      "params": {
        "tty": "params.tty_dbg"
      }
    },
    {
      "name": "term_bt",
      "plugin": "UartSerialTerminal",
      "library": "terminals",
      "params": {
        "tty": "params.tty_bt"
      }
    },
    {
      "name": "bluetooth",
      "plugin": "BT",
      "library": "mcu"
    },

    { "name": "led_0",  "plugin": "LED", "library": "mcu" },
    { "name": "led_1",  "plugin": "LED", "library": "mcu" },
    { "name": "led_2",  "plugin": "LED", "library": "mcu" },
    { "name": "led_3",  "plugin": "LED", "library": "mcu" },
    { "name": "led_4",  "plugin": "LED", "library": "mcu" },
    { "name": "led_5",  "plugin": "LED", "library": "mcu" },
    { "name": "led_6",  "plugin": "LED", "library": "mcu" },
    { "name": "led_7",  "plugin": "LED", "library": "mcu" },
    { "name": "led_8",  "plugin": "LED", "library": "mcu" },
    { "name": "led_9",  "plugin": "LED", "library": "mcu" },
    { "name": "led_10", "plugin": "LED", "library": "mcu" },
    { "name": "led_11", "plugin": "LED", "library": "mcu" },
    { "name": "led_12", "plugin": "LED", "library": "mcu" },
    { "name": "led_13", "plugin": "LED", "library": "mcu" },
    { "name": "led_14", "plugin": "LED", "library": "mcu" },
    { "name": "led_15", "plugin": "LED", "library": "mcu" }
  ],

  // Plugin connection between components
  "connections": [
    [ "u1_stm32.ports.usart1_m", "usart_debug.ports.term_s"],
    [ "u1_stm32.ports.usart1_s", "usart_debug.ports.term_m"],

    [ "u1_stm32.ports.usart2_m", "bluetooth.ports.usart_m"],
    [ "u1_stm32.ports.usart2_s", "bluetooth.ports.usart_s"],

    [ "bluetooth.ports.bt_s", "term_bt.ports.term_m"],
    [ "bluetooth.ports.bt_m", "term_bt.ports.term_s"],

    [ "led_0.ports.pin",  "u1_stm32.buses.pin_output_a", "0x00"],
    [ "led_1.ports.pin",  "u1_stm32.buses.pin_output_a", "0x01"],
    [ "led_2.ports.pin",  "u1_stm32.buses.pin_output_a", "0x02"],
    [ "led_3.ports.pin",  "u1_stm32.buses.pin_output_a", "0x03"],
    [ "led_4.ports.pin",  "u1_stm32.buses.pin_output_a", "0x04"],
    [ "led_5.ports.pin",  "u1_stm32.buses.pin_output_a", "0x05"],
    [ "led_6.ports.pin",  "u1_stm32.buses.pin_output_a", "0x06"],
    [ "led_7.ports.pin",  "u1_stm32.buses.pin_output_a", "0x07"],
    [ "led_8.ports.pin",  "u1_stm32.buses.pin_output_a", "0x08"],
    [ "led_9.ports.pin",  "u1_stm32.buses.pin_output_a", "0x09"],
    [ "led_10.ports.pin", "u1_stm32.buses.pin_output_a", "0x0A"],
    [ "led_11.ports.pin", "u1_stm32.buses.pin_output_a", "0x0B"],
    [ "led_12.ports.pin", "u1_stm32.buses.pin_output_a", "0x0C"],
    [ "led_13.ports.pin", "u1_stm32.buses.pin_output_a", "0x0D"],
    [ "led_14.ports.pin", "u1_stm32.buses.pin_output_a", "0x0E"],
    [ "led_15.ports.pin", "u1_stm32.buses.pin_output_a", "0x0F"]
  ]
}

Věnujte pozornost parametru firmware část params je název souboru, který lze načíst do virtuálního zařízení jako firmware.

Virtuální zařízení a jeho interakce s hlavním operačním systémem lze znázornit následujícím diagramem:

Aktuální testovací instance emulátoru zahrnuje interakci s COM porty hlavního operačního systému (ladění UART a UART pro modul Bluetooth). Mohou to být skutečné porty, ke kterým jsou připojena zařízení, nebo virtuální porty COM (k tomu potřebujete com0com/socat).

V současné době existují dva hlavní způsoby interakce s emulátorem zvenčí:

• protokol GDB RSP (podle toho nástroje, které tento protokol podporují, jsou Eclipse / IDA / radare2);
• interní příkazový řádek emulátoru (Argparse nebo Python).

Virtuální COM porty

Abyste mohli komunikovat s UART virtuálního zařízení na místním počítači prostřednictvím terminálu, musíte vytvořit pár přidružených virtuálních COM portů. V našem případě jeden port používá emulátor a druhý terminálový program (PuTTY nebo obrazovka):

Pomocí com0com

Virtuální COM porty se konfigurují pomocí instalačního nástroje ze sady com0com (verze konzoly - C: Program Files (x86) com0comsetupс.exe, nebo GUI verze - C: Program Files (x86) com0comsetupg.exe):

Zaškrtněte políčka povolit přetečení vyrovnávací paměti pro všechny vytvořené virtuální porty, jinak bude emulátor čekat na odpověď z COM portu.

Pomocí socat

Na systémech UNIX jsou virtuální porty COM automaticky vytvářeny emulátorem pomocí nástroje socat; k tomu stačí zadat předponu v názvu portu při spuštění emulátoru. socat:.

Interní rozhraní příkazového řádku (Argparse nebo Python)

Protože Kopycat je konzolová aplikace, emulátor poskytuje dvě možnosti rozhraní příkazového řádku pro interakci s jeho objekty a proměnnými: Argparse a Python.

Argparse je rozhraní CLI zabudované do Kopycat a je vždy dostupné všem.

Alternativním CLI je interpret Pythonu. Chcete-li jej používat, musíte nainstalovat modul Jep Python a nakonfigurovat emulátor pro práci s Pythonem (bude použit interpret Pythonu nainstalovaný v hlavním systému uživatele).

Instalace modulu Python Jep

Pod Linuxem lze Jep nainstalovat přes pip:

pip install jep

Chcete-li nainstalovat Jep na Windows, musíte nejprve nainstalovat Windows SDK a odpovídající Microsoft Visual Studio. Trochu jsme vám to usnadnili a staví WHL JEP pro aktuální verze Pythonu pro Windows, takže modul lze nainstalovat ze souboru:

pip install jep-3.8.2-cp27-cp27m-win_amd64.whl

Chcete-li zkontrolovat instalaci Jep, musíte spustit na příkazovém řádku:

python -c "import jep"

Jako odpověď by měla být přijata následující zpráva:

ImportError: Jep is not supported in standalone Python, it must be embedded in Java.

V dávkovém souboru emulátoru pro váš systém (copycat.bat - pro Windows, imitátor - pro Linux) do seznamu parametrů DEFAULT_JVM_OPTS přidat další parametr Djava.library.path — musí obsahovat cestu k nainstalovanému modulu Jep.

Výsledkem pro Windows by měl být řádek takto:

set DEFAULT_JVM_OPTS="-XX:MaxMetaspaceSize=256m" "-XX:+UseParallelGC" "-XX:SurvivorRatio=6" "-XX:-UseGCOverheadLimit" "-Djava.library.path=C:/Python27/Lib/site-packages/jep"

Spuštění Kopycatu

Emulátorem je konzolová aplikace JVM. Spuštění se provádí pomocí skriptu příkazového řádku operačního systému (sh/cmd).

Příkaz ke spuštění pod Windows:

binkopycat -g 23946 -n rhino -l user -y library -p firmware=firmwarerhino_pass.bin,tty_dbg=COM26,tty_bt=COM28

Příkaz ke spuštění pod Linuxem pomocí nástroje socat:

./bin/kopycat -g 23946 -n rhino -l user -y library -p firmware=./firmware/rhino_pass.bin, tty_dbg=socat:./COM26,tty_bt=socat:./COM28

• -g 23646 — TCP port, který bude otevřen pro přístup k serveru GDB;
• -n rhino — název hlavního modulu systému (smontovaného zařízení);
• -l user — název knihovny pro vyhledání hlavního modulu;
• -y library — cesta k vyhledání modulů obsažených v zařízení;
• firmwarerhino_pass.bin — cesta k souboru firmwaru;
• COM26 a COM28 jsou virtuální COM porty.

V důsledku toho se zobrazí výzva Python > (nebo Argparse >):

18:07:59 INFO [eFactoryBuilder.create ]: Module top successfully created as top
18:07:59 INFO [ Module.initializeAndRes]: Setup core to top.u1_stm32.cortexm0.arm for top
18:07:59 INFO [ Module.initializeAndRes]: Setup debugger to top.u1_stm32.dbg for top
18:07:59 WARN [ Module.initializeAndRes]: Tracer wasn't found in top...
18:07:59 INFO [ Module.initializeAndRes]: Initializing ports and buses...
18:07:59 WARN [ Module.initializePortsA]: ATTENTION: Some ports has warning use printModulesPortsWarnings to see it...
18:07:59 FINE [ ARMv6CPU.reset ]: Set entry point address to 08006A75
18:07:59 INFO [ Module.initializeAndRes]: Module top is successfully initialized and reset as a top cell!
18:07:59 INFO [ Kopycat.open ]: Starting virtualization of board top[rhino] with arm[ARMv6Core]
18:07:59 INFO [ GDBServer.debuggerModule ]: Set new debugger module top.u1_stm32.dbg for GDB_SERVER(port=23946,alive=true)
Python >

Interakce s IDA Pro

Pro zjednodušení testování používáme jako zdrojový soubor pro analýzu v IDA ve formuláři firmware Rhina soubor ELF (tam jsou uloženy metainformace).

Můžete také použít hlavní firmware bez meta informací.

Po spuštění Kopycat v IDA Pro přejděte v nabídce Debugger na položku „Přepnout ladicí program…"a vyberte"Vzdálený ladicí program GDB". Dále nastavte připojení: menu Debugger – Možnosti zpracování…

Nastavte hodnoty:

• Aplikace - libovolná hodnota
• Název hostitele: 127.0.0.1 (nebo IP adresa vzdáleného počítače, na kterém běží Kopycat)
• Port: 23946

Nyní je k dispozici tlačítko ladění (klávesa F9):

Klepnutím na něj se připojíte k modulu ladicího programu v emulátoru. IDA přejde do režimu ladění, zpřístupní se další okna: informace o registrech, o zásobníku.

Nyní můžeme používat všechny standardní funkce debuggeru:

• provádění pokynů krok za krokem (Vstupte и Překročit — klávesy F7 a F8;
• spuštění a pozastavení provádění;
• vytváření zarážek pro kód i data (klávesa F2).

Připojení k debuggeru neznamená spuštění kódu firmwaru. Aktuální pozice provádění musí být adresa 0x08006A74 — zahájení funkce Reset_Handler. Pokud projdete seznamem dolů, můžete vidět volání funkce hlavní. Na tento řádek můžete umístit kurzor (adresa 0x08006ABE) a proveďte operaci Spustit až do kurzoru (klávesa F4).

Dále můžete stisknutím klávesy F7 vstoupit do funkce hlavní.

Pokud spustíte příkaz Pokračujte v procesu (klávesa F9), poté se zobrazí okno „Čekejte prosím“ s jediným tlačítkem Pozastavit:

Když stisknete Pozastavit provádění kódu firmwaru je pozastaveno a lze v něm pokračovat ze stejné adresy v kódu, kde bylo přerušeno.

Pokud budete pokračovat ve spouštění kódu, uvidíte na terminálech připojených k virtuálním COM portům následující řádky:

Přítomnost řádku „state bypass“ znamená, že virtuální modul Bluetooth přešel do režimu příjmu dat z COM portu uživatele.

Nyní můžete v terminálu Bluetooth (na obrázku COM29) zadávat příkazy v souladu s protokolem Rhino. Například příkaz „MEOW“ vrátí řetězec „mur-mur“ do terminálu Bluetooth:

Napodobit mě ne úplně

Při sestavování emulátoru si můžete vybrat úroveň detailů/emulace konkrétního zařízení. Například modul Bluetooth lze emulovat různými způsoby:

• zařízení je plně emulováno s úplnou sadou příkazů;
• AT příkazy jsou emulovány a datový tok je přijímán z COM portu hlavního systému;
• virtuální zařízení poskytuje kompletní přesměrování dat na skutečné zařízení;
• jako jednoduchý útržek, který vždy vrátí "OK".

Aktuální verze emulátoru využívá druhý přístup - virtuální Bluetooth modul provede konfiguraci, po které se přepne do režimu „proxy“ dat z COM portu hlavního systému na UART port emulátoru.

Zvažme možnost jednoduché instrumentace kódu v případě, že některá část periferie není implementována. Pokud například nebyl vytvořen časovač zodpovědný za řízení přenosu dat do DMA (kontrola se provádí ve funkci ws2812b_waitnachází se na 0x08006840), pak bude firmware vždy čekat na reset příznaku zaneprázdněnýnachází se na 0x200004C4který ukazuje obsazenost datové linky DMA:

Tuto situaci můžeme obejít ručním resetováním příznaku zaneprázdněný ihned po jeho instalaci. V IDA Pro můžete vytvořit funkci Pythonu a volat ji v bodě přerušení a samotný bod přerušení vložit do kódu po zapsání hodnoty 1 do příznaku zaneprázdněný.

Obsluha bodu zlomu

Nejprve si v IDA vytvoříme funkci Pythonu. Jídelní lístek Soubor - příkaz skriptu...

Přidejte nový úryvek do seznamu vlevo, pojmenujte jej (např. BPT),
Do textového pole vpravo zadejte kód funkce:

def skip_dma():
    print "Skipping wait ws2812..."
    value = Byte(0x200004C4)
    if value == 1:
        PatchDbgByte(0x200004C4, 0)
return False

Poté stiskneme Běh a zavřete okno skriptu.

Nyní pojďme ke kódu na adrese 0x0800688A, nastavte bod přerušení (klávesa F2), upravte jej (kontextové menu Upravit zarážku...), nezapomeňte nastavit typ skriptu na Python:

Pokud je aktuální hodnota příznaku zaneprázdněný rovná se 1, pak byste měli funkci provést skip_dma v řádku skriptu:

Pokud spustíte firmware ke spuštění, spuštění kódu obslužného programu bodu přerušení lze vidět v okně IDA Výstup po řadě Skipping wait ws2812.... Firmware nyní nebude čekat na reset příznaku zaneprázdněný.

Interakce s emulátorem

Je nepravděpodobné, že by emulace kvůli emulaci způsobovala potěšení a radost. Je mnohem zajímavější, pokud emulátor pomůže výzkumníkovi vidět data v paměti nebo navázat interakci vláken.

Ukážeme vám, jak dynamicky navázat interakci mezi úlohami RTOS. Nejprve byste měli pozastavit provádění kódu, pokud je spuštěn. Pokud přejdete na funkci bluetooth_task_entry do větve zpracování příkazu „LED“ (adresa 0x080057B8), pak můžete vidět, co je nejprve vytvořeno a poté odesláno do systémové fronty ledControlQueueHandle nějakou zprávu.

Pro přístup k proměnné byste měli nastavit bod přerušení ledControlQueueHandlenachází se na 0x20000624 a pokračujte ve provádění kódu:

V důsledku toho k zastavení dojde nejprve na adrese 0x080057CA před voláním funkce osMailAlloc, pak na adrese 0x08005806 před voláním funkce osMailPut, pak po chvíli - na adresu 0x08005BD4 (před voláním funkce osMailGet), která patří k funkci leds_task_entry (LED-task), tedy úkoly se přepnuly, a nyní LED-task získal řízení.

Tímto jednoduchým způsobem můžete zjistit, jak se úlohy RTOS vzájemně ovlivňují.

Samozřejmě ve skutečnosti může být interakce úkolů složitější, ale pomocí emulátoru se sledování této interakce stává méně pracným.

Zde Můžete se podívat na krátké video ze spuštění emulátoru a interakce s IDA Pro.

Spusťte pomocí Radare2

Nelze ignorovat tak univerzální nástroj, jakým je Radare2.

Chcete-li se připojit k emulátoru pomocí r2, příkaz by vypadal takto:

radare2 -A -a arm -b 16 -d gdb://localhost:23946 rhino_fw42k6.elf

Spuštění je nyní k dispozici (dc) a pozastavit provádění (Ctrl+C).

Bohužel v tuto chvíli má r2 problémy při práci s hardwarovým gdb serverem a rozložením paměti; z tohoto důvodu nefungují breakpointy a kroky (příkaz ds). Doufáme, že to bude brzy opraveno.

Běh s Eclipse

Jednou z možností použití emulátoru je odladění firmwaru vyvíjeného zařízení. Pro názornost použijeme i firmware Rhina. Zdroje firmwaru si můžete stáhnout proto.

Jako IDE použijeme Eclipse ze sady System Workbench pro STM32.

Aby emulátor nahrál firmware přímo zkompilovaný v Eclipse, musíte přidat parametr firmware=null na příkaz ke spuštění emulátoru:

binkopycat -g 23946 -n rhino -l user -y modules -p firmware=null,tty_dbg=COM26,tty_bt=COM28

Nastavení konfigurace ladění

V Eclipse vyberte nabídku Spustit – ladění konfigurací... V okně, které se otevře, v sekci Hardwarové ladění GDB musíte přidat novou konfiguraci a poté na kartě „Hlavní“ určit aktuální projekt a aplikaci pro ladění:

Na kartě „Debugger“ musíte zadat příkaz GDB:
${openstm32_compiler_path}arm-none-eabi-gdb

A také zadejte parametry pro připojení k serveru GDB (hostitel a port):

Na kartě „Spuštění“ musíte zadat následující parametry:

• povolit zaškrtávací políčko Načíst obrázek (takže sestavený obraz firmwaru se nahraje do emulátoru);
• povolit zaškrtávací políčko Symboly zatížení;
• přidat spouštěcí příkaz: set $pc = *0x08000004 (nastavte registr PC na hodnotu z paměti na adrese 0x08000004 - tam je uložena adresa ResetHandler).

Poznámka, pokud nechcete stahovat soubor firmwaru z Eclipse, pak možnosti Načíst obrázek и Spustit příkazy není třeba uvádět.

Po kliknutí na Debug můžete pracovat v režimu ladění:

• krok za krokem provádění kódu
  
• interakce s body přerušení
  

Poznámka. Eclipse má, hmm... nějaké vtípky... a ty s nimi musíš žít. Pokud se například při spouštění ladicího programu zobrazí zpráva „No source available for „0x0″“, spusťte příkaz Step (F5)

Místo závěru

Emulace nativního kódu je velmi zajímavá věc. Vývojáři zařízení mohou ladit firmware bez skutečného zařízení. Pro výzkumníka je to příležitost provádět dynamickou analýzu kódu, což není vždy možné ani se zařízením.

Chceme specialistům poskytnout nástroj, který je pohodlný, středně jednoduchý a jeho nastavení a spuštění nezabere mnoho úsilí a času.

Napište do komentářů své zkušenosti s používáním hardwarových emulátorů. Zveme vás k diskuzi a rádi zodpovíme dotazy.

Průzkumu se mohou zúčastnit pouze registrovaní uživatelé. Přihlásit se, prosím.

K čemu emulátor používáš?

• Vyvíjím (ladím) firmware

• Zkoumám firmware

• Spouštím hry (Dendi, Sega, PSP)

• něco jiného (pište do komentářů)

Hlasovalo 7 uživatelů. 2 uživatelů se zdrželo hlasování.

Jaký software používáte k emulaci nativního kódu?

• QEMU

• Motor Unicorn

• Proteus

• něco jiného (pište do komentářů)

Hlasovalo 6 uživatelů. 2 uživatelů se zdrželo hlasování.

Co byste chtěli zlepšit v emulátoru, který používáte?

• Chci rychlost

• Chci snadné nastavení/spouštění

• Chci více možností pro interakci s emulátorem (API, háčky)

• Jsem spokojený se vším

• něco jiného (pište do komentářů)

Hlasovalo 8 uživatelů. 1 uživatel se zdržel hlasování.

Zdroj: www.habr.com