Translated ['src/generic-methodologies-and-resources/phishing-methodolog

.gitignore

@@ -11,3 +11,4 @@ book
 book/*
 hacktricks-preprocessor.log
 hacktricks-preprocessor-error.log
+searchindex.js

src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md

@@ -3,97 +3,111 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 
-## Fizički use-after-free
+## iOS Exploit Mitigations
 
-Ovo je sažetak posta sa [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html), a dodatne informacije o exploit-u koji koristi ovu tehniku mogu se naći na [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd)
+- **Code Signing** u iOS funkcioniše tako što svaki izvršni kod (apps, libraries, extensions, itd.) mora biti kriptografski potpisan sertifikatom koji izdaje Apple. Kada se kod učitava, iOS proverava digitalni potpis protiv Apple-ovog root sertifikata. Ako je potpis nevažeći, nedostaje ili je izmenjen, OS odbija da ga pokrene. Ovo onemogućava napadačima da ubace maliciozni kod u legitimne aplikacije ili pokreću unsigned binarije, efikasno zaustavljajući većinu exploit lanaca koji zavise od izvršavanja proizvoljnog ili izmenjenog koda.
+- **CoreTrust** je iOS subsistem odgovoran za provođenje provere potpisivanja koda u runtime-u. On direktno verifikuje potpise koristeći Apple-ov root sertifikat bez oslanjanja na keširane trust store-ove, što znači da samo binariji potpisani od strane Apple-a (ili sa važećim entitlements) mogu da se izvršavaju. CoreTrust osigurava da čak i ako napadač izmeni aplikaciju nakon instalacije, modifikuje sistemske biblioteke ili pokuša da učita unsigned kod, sistem će blokirati izvršavanje osim ako je kod i dalje pravilno potpisan. Ova stroga primena zatvara mnoge post-exploitation vektore koje su starije iOS verzije dozvoljavale kroz slabije ili zaobilažive provere potpisa.
+- **Data Execution Prevention (DEP)** označava regije memorije kao neizvršne osim ako eksplicitno ne sadrže kod. To sprečava napadače da ubacuju shellcode u data regione (kao što su stack ili heap) i da ga pokreću, prisiljavajući ih da se oslone na složenije tehnike kao što je ROP (Return-Oriented Programming).
+- **ASLR (Address Space Layout Randomization)** nasumično raspoređuje adrese memorije za kod, biblioteke, stack i heap pri svakom pokretanju sistema. To otežava napadačima da predvide gde se nalaze korisne instrukcije ili gadgets, narušavajući mnoge exploit lance koji zavise od fiksnih rasporeda memorije.
+- **KASLR (Kernel ASLR)** primenjuje isti koncept randomizacije na iOS kernel. Mešanjem kernel base adrese pri svakom boot-u, sprečava napadače da pouzdano lociraju kernel funkcije ili strukture, povećavajući težinu kernel-level exploita koji bi inače omogućili potpunu kontrolu nad sistemom.
+- **Kernel Patch Protection (KPP)**, takođe poznat kao **AMCC (Apple Mobile File Integrity)** u iOS-u, kontinuirano nadgleda kernel-ove code page-ove da bi osigurao da nisu modifikovani. Ako se otkrije bilo kakvo mešanje—npr. pokušaj exploita da patch-uje kernel funkcije ili ubaci maliciozni kod—uređaj će odmah panic-ovati i restartovati se. Ova zaštita otežava postojane kernel exploite, jer napadači ne mogu jednostavno hook-ovati ili patch-ovati kernel instrukcije bez izazivanja sistemskog pada.
+- **Kernel Text Readonly Region (KTRR)** je hardverska bezbednosna funkcija uvedena na iOS uređajima. Koristi memorijski kontroler CPU-a da označi kernel-ovu code (text) sekciju kao trajno read-only nakon boot-a. Jednom zaključana, čak ni kernel ne može menjati tu memorijsku regiju. Ovo sprečava napadače—i čak privilegovani kod—from da patch-uju kernel instrukcije u runtime-u, zatvarajući veliku klasu exploita koji su se oslanjali na direktnu modifikaciju kernel koda.
+- **Pointer Authentication Codes (PAC)** koriste kriptografske potpise ugrađene u neiskorišćene bitove pokazivača da bi verifikovali njihov integritet pre upotrebe. Kada se pokazivač (npr. return address ili function pointer) kreira, CPU ga potpisuje tajnim ključem; pre dereferenciranja, CPU proverava potpis. Ako je pokazivač izmenjen, provera ne uspeva i izvršavanje prestaje. Ovo sprečava napadače da falsifikuju ili ponovo koriste korumpirane pokazivače u mem-korupciji, otežavajući tehnike poput ROP ili JOP.
+- **Privilege Access Never (PAN)** je hardverska funkcija koja sprečava kernel (privileged mode) da direktno pristupi user-space memoriji osim ako eksplicitno ne omogući pristup. Ovo zaustavlja napadače koji su stekli kernel code execution da lako čitaju ili pišu user memoriju radi eskalacije privilegija ili krađe osetljivih podataka. Stroga separacija smanjuje uticaj kernel exploita i blokira mnoge uobičajene tehnike eskalacije privilegija.
+- **Page Protection Layer (PPL)** je iOS bezbednosni mehanizam koji štiti kritične memorijske regione koje kernel upravlja, naročito one povezane sa code signing-om i entitlements. On primenjuje stroge write protection koristeći MMU (Memory Management Unit) i dodatne provere, osiguravajući da čak ni privilegovani kernel kod ne može proizvoljno menjati osetljive stranice. Ovo sprečava napadače koji dobiju kernel-level izvršavanje da mešaju strukture važne za bezbednost, čineći persisteniciju i zaobilaženje code-signing-a znatno težim.
+
+
+## Physical use-after-free
+
+This is a summary from the post from [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) moreover further information about exploit using this technique can be found in [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd)
 
 ### Upravljanje memorijom u XNU <a href="#memory-management-in-xnu" id="memory-management-in-xnu"></a>
 
-Virtuelni adresni prostor za procese korisnika na iOS-u prostire se od **0x0 do 0x8000000000**. Međutim, ove adrese se ne preslikavaju direktno na fizičku memoriju. Umesto toga, **kernel** koristi **page tables** da prevede virtuelne adrese u stvarne **fizičke adrese**.
+The **virtual memory address space** for user processes on iOS spans from **0x0 to 0x8000000000**. However, these addresses don’t directly map to physical memory. Instead, the **kernel** uses **page tables** to translate virtual addresses into actual **physical addresses**.
 
-#### Nivoi page tabela u iOS-u
+#### Levels of Page Tables in iOS
 
-Page table-ovi su organizovani hijerarhijski u tri nivoa:
+Page tables are organized hierarchically in three levels:
 
 1. **L1 Page Table (Level 1)**:
-* Svaki unos ovde predstavlja veliki opseg virtuelne memorije.
-* Pokriva **0x1000000000 bytes** (ili **256 GB**) virtuelne memorije.
+* Each entry here represents a large range of virtual memory.
+* It covers **0x1000000000 bytes** (or **256 GB**) of virtual memory.
 2. **L2 Page Table (Level 2)**:
-* Unos ovde predstavlja manji region virtuelne memorije, konkretno **0x2000000 bytes** (32 MB).
-* L1 unos može pokazivati na L2 tabelu ako ne može sam da mapira ceo region.
+* An entry here represents a smaller region of virtual memory, specifically **0x2000000 bytes** (32 MB).
+* An L1 entry may point to an L2 table if it can't map the entire region itself.
 3. **L3 Page Table (Level 3)**:
-* Ovo je najfiniji nivo, gde svaki unos mapira jednu **4 KB** memorijsku stranicu.
-* L2 unos može pokazivati na L3 tabelu ako je potrebna detaljnija kontrola.
+* This is the finest level, where each entry maps a single **4 KB** memory page.
+* An L2 entry may point to an L3 table if more granular control is needed.
 
-#### Mapiranje virtuelne u fizičku memoriju
+#### Mapping Virtual to Physical Memory
 
 * **Direct Mapping (Block Mapping)**:
-* Neki unosi u page tabeli direktno **mapiraju opseg virtuelnih adresa** na kontinualan opseg fizičkih adresa (kao prečica).
+* Some entries in a page table directly **map a range of virtual addresses** to a contiguous range of physical addresses (like a shortcut).
 * **Pointer to Child Page Table**:
-* Ako je potrebna finija kontrola, unos na jednom nivou (npr. L1) može pokazivati na **child page table** na sledećem nivou (npr. L2).
+* If finer control is needed, an entry in one level (e.g., L1) can point to a **child page table** at the next level (e.g., L2).
 
-#### Primer: mapiranje virtuelne adrese
+#### Example: Mapping a Virtual Address
 
-Recimo da pokušate da pristupite virtuelnoj adresi **0x1000000000**:
+Let’s say you try to access the virtual address **0x1000000000**:
 
 1. **L1 Table**:
-* Kernel proverava odgovarajući unos u L1 page tabeli za ovu virtuelnu adresu. Ako ima **pointer** ka L2 page tabeli, prelazi u tu L2 tabelu.
+* The kernel checks the L1 page table entry corresponding to this virtual address. If it has a **pointer to an L2 page table**, it goes to that L2 table.
 2. **L2 Table**:
-* Kernel proverava L2 page tabelu za detaljnije mapiranje. Ako ovaj unos pokazuje na **L3 page table**, prelazi se tamo.
+* The kernel checks the L2 page table for a more detailed mapping. If this entry points to an **L3 page table**, it proceeds there.
 3. **L3 Table**:
-* Kernel pregleda finalni L3 unos, koji pokazuje na **fizičku adresu** stvarne memorijske stranice.
+* The kernel looks up the final L3 entry, which points to the **physical address** of the actual memory page.
 
-#### Primer mapiranja adresa
+#### Example of Address Mapping
 
-Ako upišete fizičku adresu **0x800004000** u prvi indeks L2 tabele, onda:
+If you write the physical address **0x800004000** into the first index of the L2 table, then:
 
-* Virtuelne adrese od **0x1000000000** do **0x1002000000** mapiraju se na fizičke adrese od **0x800004000** do **0x802004000**.
-* Ovo je **block mapping** na L2 nivou.
+* Virtual addresses from **0x1000000000** to **0x1002000000** map to physical addresses from **0x800004000** to **0x802004000**.
+* This is a **block mapping** at the L2 level.
 
-Alternativno, ako L2 unos pokazuje na L3 tabelu:
+Alternatively, if the L2 entry points to an L3 table:
 
-* Svaka 4 KB stranica u virtuelnom adresnom opsegu **0x1000000000 -> 0x1002000000** bi bila mapirana pojedinačnim unosima u L3 tabeli.
+* Each 4 KB page in the virtual address range **0x1000000000 -> 0x1002000000** would be mapped by individual entries in the L3 table.
 
 ### Physical use-after-free
 
-Physički use-after-free (UAF) se dešava kada:
+A **physical use-after-free** (UAF) occurs when:
 
-1. Proces **alokira** neku memoriju kao **readable i writable**.
-2. **Page tables** su ažurirane da mapiraju ovu memoriju na specifičnu fizičku adresu kojoj proces može pristupiti.
-3. Proces **dealocira** (oslobodi) memoriju.
-4. Međutim, zbog **baga**, kernel **zaboravi da ukloni mapiranje** iz page tabela, iako označi odgovarajuću fizičku memoriju kao slobodnu.
-5. Kernel zatim može **ponovo alocirati ovu "oslobođenu" fizičku memoriju** za druge svrhe, kao što su **kernel podaci**.
-6. Pošto mapiranje nije uklonjeno, proces i dalje može **čitati i pisati** tu fizičku memoriju.
+1. A process **allocates** some memory as **readable and writable**.
+2. The **page tables** are updated to map this memory to a specific physical address that the process can access.
+3. The process **deallocates** (frees) the memory.
+4. However, due to a **bug**, the kernel **forgets to remove the mapping** from the page tables, even though it marks the corresponding physical memory as free.
+5. The kernel can then **reallocate this "freed" physical memory** for other purposes, like **kernel data**.
+6. Since the mapping wasn’t removed, the process can still **read and write** to this physical memory.
 
-To znači da proces može pristupiti **stranicama kernel memorije**, koje mogu sadržavati osetljive podatke ili strukture, potencijalno omogućavajući napadaču da **manipuliše kernel memorijom**.
+This means the process can access **pages of kernel memory**, which could contain sensitive data or structures, potentially allowing an attacker to **manipulate kernel memory**.
 
 ### IOSurface Heap Spray
 
-Pošto napadač ne može kontrolisati koje konkretne kernel stranice će biti dodeljene oslobođenoj memoriji, koristi se tehnika zvana **heap spray**:
+Since the attacker can’t control which specific kernel pages will be allocated to freed memory, they use a technique called **heap spray**:
 
-1. Napadač **kreira veliki broj IOSurface objekata** u kernel memoriji.
-2. Svaki IOSurface objekat sadrži **magničnu vrednost** u jednom od svojih polja, što ga čini lakim za identifikaciju.
-3. Oni **skeniraju oslobođene stranice** da vide da li je neki od ovih IOSurface objekata dospeo na oslobođenu stranicu.
-4. Kada pronađu IOSurface objekat na oslobođenoj stranici, mogu ga iskoristiti za **čitanje i pisanje kernel memorije**.
+1. The attacker **creates a large number of IOSurface objects** in kernel memory.
+2. Each IOSurface object contains a **magic value** in one of its fields, making it easy to identify.
+3. They **scan the freed pages** to see if any of these IOSurface objects landed on a freed page.
+4. When they find an IOSurface object on a freed page, they can use it to **read and write kernel memory**.
 
-Više informacija o ovome na [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups)
+More info about this in [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups)
 
 > [!TIP]
-> Imajte na umu da iOS 16+ (A12+) uređaji uvode hardverske mitigacije (kao što su PPL ili SPTM) koje čine fizičke UAF tehnike znatno manje izvodljivim.
-> PPL nameće stroga MMU ograničenja na stranicama vezanim za code signing, entitlements i osetljive kernel podatke, pa čak i ako se stranica ponovo koristi, upisi iz userlanda ili kompromitovanog kernel koda u PPL-zaštićene stranice su blokirani.
-> Secure Page Table Monitor (SPTM) proširuje PPL tako što ojačava same page table update-ove. On osigurava da čak ni privilegovani kernel kod ne može neprimetno remapirati oslobođene stranice ili menjati mapiranja bez prolaska kroz sigurnosne provere.
-> KTRR (Kernel Text Read-Only Region) zaključava sekciju kernel koda kao samo za čitanje posle boot-a. Ovo sprečava bilo kakve izmene kernel koda u toku rada, zatvarajući jedan od glavnih vektora napada na koji se fizički UAF exploiti često oslanjaju.
-> Pored toga, `IOSurface` alokacije su manje predvidljive i teže ih je mapirati u user-accessible regione, što čini trik sa skeniranjem "magične vrednosti" mnogo manje pouzdanim. I `IOSurface` je sada zaštićen entitlements i sandbox ograničenjima.
+> Be aware that iOS 16+ (A12+) devices bring hardware mitigations (like PPL or SPTM) that make physical UAF techniques far less viable.
+> PPL enforces strict MMU protections on pages related to code signing, entitlements, and sensitive kernel data, so, even if a page gets reused, writes from userland or compromised kernel code to PPL-protected pages are blocked.
+> Secure Page Table Monitor (SPTM) extends PPL by hardening page table updates themselves. It ensures that even privileged kernel code cannot silently remap freed pages or tamper with mappings without going through secure checks.
+> KTRR (Kernel Text Read-Only Region), which locks down the kernel’s code section as read-only after boot. This prevents any runtime modifications to kernel code, closing off a major attack vector that physical UAF exploits often rely on.
+> Moreover, `IOSurface` allocations are less predictable and harder to map into user-accessible regions, which makes the “magic value scanning” trick much less reliable. And `IOSurface` is now guarded by entitlements and sandbox restrictions.
 
 ### Step-by-Step Heap Spray Process
 
-1. **Spray IOSurface Objects**: Napadač kreira mnogo IOSurface objekata sa specijalnim identifikatorom ("magic value").
-2. **Scan Freed Pages**: Proveravaju da li je neki od objekata alociran na oslobođenoj stranici.
-3. **Read/Write Kernel Memory**: Manipulacijom polja u IOSurface objektu, stiču sposobnost da izvode **arbitrary reads and writes** u kernel memoriji. To im omogućava da:
-* Iskoriste jedno polje da **čitaju bilo koju 32-bit vrednost** u kernel memoriji.
-* Iskoriste drugo polje da **pišu 64-bit vrednosti**, postižući stabilan **kernel read/write primitive**.
+1. **Spray IOSurface Objects**: The attacker creates many IOSurface objects with a special identifier ("magic value").
+2. **Scan Freed Pages**: They check if any of the objects have been allocated on a freed page.
+3. **Read/Write Kernel Memory**: By manipulating fields in the IOSurface object, they gain the ability to perform **arbitrary reads and writes** in kernel memory. This lets them:
+* Use one field to **read any 32-bit value** in kernel memory.
+* Use another field to **write 64-bit values**, achieving a stable **kernel read/write primitive**.
 
-Generišite IOSurface objekte sa magičnom vrednošću IOSURFACE\_MAGIC za kasnije pretraživanje:
+Generate IOSurface objects with the magic value IOSURFACE\_MAGIC to later search for:
 ```c
 void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) {
 if (*nClients >= 0x4000) return;
@@ -148,9 +162,9 @@ free(surfaceIDs);
 return 0;
 }
 ```
-### Postizanje čitanja/pisanja u kernelu pomoću IOSurface
+### Postizanje čitanja/brisanja u kernelu pomoću IOSurface
 
-Nakon što se uspostavi kontrola nad IOSurface objektom u kernel memoriji (mapiran na oslobođenu fizičku stranicu kojoj korisnički prostor ima pristup), možemo ga iskoristiti za **arbitrary kernel read and write operations**.
+Nakon što dobijemo kontrolu nad IOSurface objektom u kernel memoriji (mapiranom na oslobođenu fizičku stranicu dostupnu iz userspace), možemo ga iskoristiti za **arbitrarne operacije čitanja i pisanja u kernelu**.
 
 **Ključna polja u IOSurface**
 
@@ -159,14 +173,14 @@ IOSurface objekat ima dva ključna polja:
 1. **Use Count Pointer**: Omogućava **32-bit read**.
 2. **Indexed Timestamp Pointer**: Omogućava **64-bit write**.
 
-Prepisivanjem ovih pokazivača preusmeravamo ih na proizvoljne adrese u kernel memoriji, čime dobijamo mogućnost čitanja/pisanja.
+Prepisivanjem ovih pokazivača preusmeravamo ih na proizvoljne adrese u kernel memoriji, čime omogućavamo mogućnosti čitanja/pisanja.
 
 #### 32-Bit Kernel Read
 
-Za izvođenje čitanja:
+Da biste izvršili čitanje:
 
 1. Prepišite **use count pointer** da pokazuje na ciljnu adresu umanjenu za offset od 0x14 bajta.
-2. Koristite `get_use_count` method da pročitate vrednost na toj adresi.
+2. Upotrebite `get_use_count` metodu da pročitate vrednost na toj adresi.
 ```c
 uint32_t get_use_count(io_connect_t client, uint32_t surfaceID) {
 uint64_t args[1] = {surfaceID};
@@ -188,8 +202,8 @@ return value;
 
 Da biste izvršili upis:
 
-1. Prepišite **indexed timestamp pointer** da pokazuje na ciljnu adresu.
-2. Koristite `set_indexed_timestamp` metodu da upišete 64-bitnu vrednost.
+1. Prepišite **indexed timestamp pointer** na ciljnu adresu.
+2. Iskoristite metodu `set_indexed_timestamp` da upišete 64-bit vrednost.
 ```c
 void set_indexed_timestamp(io_connect_t client, uint32_t surfaceID, uint64_t value) {
 uint64_t args[3] = {surfaceID, 0, value};
@@ -206,10 +220,10 @@ iosurface_set_indexed_timestamp_pointer(info.object, orig);
 #### Exploit Flow Recap
 
 1. **Trigger Physical Use-After-Free**: Slobodne stranice su dostupne za ponovnu upotrebu.
-2. **Spray IOSurface Objects**: Alocirajte mnogo IOSurface objekata sa jedinstvenom "magic value" u kernel memoriji.
-3. **Identify Accessible IOSurface**: Pronađite IOSurface na oslobođenoj stranici kojom upravljate.
-4. **Abuse Use-After-Free**: Izmenite pokazivače u IOSurface objektu kako biste omogućili proizvoljno **kernel read/write** putem IOSurface metoda.
+2. **Spray IOSurface Objects**: Alociraj mnogo IOSurface objekata sa jedinstvenom "magic value" u kernel memory.
+3. **Identify Accessible IOSurface**: Lociraj IOSurface na oslobođenoj stranici koju kontroliš.
+4. **Abuse Use-After-Free**: Izmeni pokazivače u IOSurface objektu kako bi omogućio proizvoljno **kernel read/write** preko IOSurface metoda.
 
-Sa ovim primitivima, exploit obezbeđuje kontrolisano **32-bit reads** i **64-bit writes** u kernel memoriju. Dalji koraci za jailbreak mogu uključivati stabilnije read/write primitive, koje mogu zahtevati zaobilaženje dodatnih zaštita (npr. PPL na novijim arm64e uređajima).
+Sa ovim primitivima, exploit obezbeđuje kontrolisane **32-bit reads** i **64-bit writes** u kernel memory. Dalji koraci za jailbreak mogli bi uključivati stabilnije read/write primitive, koje mogu zahtevati zaobilaženje dodatnih zaštita (npr. PPL na novijim arm64e uređajima).
 
 {{#include ../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/phishing-methodology/detecting-phising.md

@@ -1,69 +1,147 @@
-# Otkrivanje Phishing-a
+# Detecting Phishing
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Uvod
 
-Da biste otkrili pokušaj phishing-a, važno je **razumeti tehnike phishing-a koje se danas koriste**. Na roditeljskoj stranici ovog posta možete pronaći te informacije, pa ako niste upoznati sa tehnikama koje se danas koriste, preporučujem vam da odete na roditeljsku stranicu i pročitate barem taj deo.
+Da biste otkrili phishing pokušaj važno je **razumeti phishing tehnike koje se danas koriste**. Na roditeljskoj stranici ovog posta možete pronaći te informacije, pa ako niste upoznati koje se tehnike danas koriste preporučujem da odete na roditeljsku stranicu i pročitate barem taj deo.
 
-Ovaj post se zasniva na ideji da će **napadači pokušati na neki način da imituju ili koriste ime domena žrtve**. Ako se vaš domen zove `example.com` i ako ste phishing-ovani koristeći potpuno drugačije ime domena, kao što je `youwonthelottery.com`, ove tehnike neće ga otkriti.
+Ovaj post se zasniva na ideji da će **napadači pokušati na neki način imitirati ili koristiti domen žrtve**. Ako se vaš domen zove `example.com` i budete phished koristeći potpuno drugačiji domen iz nekog razloga poput `youwonthelottery.com`, ove tehnike to neće otkriti.
 
-## Varijacije imena domena
+## Domain name variations
 
-Relativno je **lako** da se **otkriju** ti **phishing** pokušaji koji će koristiti **sličan naziv domena** unutar email-a.\
-Dovoljno je da **generišete listu najverovatnijih phishing imena** koje napadač može koristiti i **proverite** da li je **registrovano** ili jednostavno proverite da li postoji neki **IP** koji ga koristi.
+Prilično je **lako** **otkriti** one **phishing** pokušaje koji će koristiti **sličan domen** unutar emaila.\
+Dovoljno je **generisati listu najverovatnijih phishing imena** koja bi napadač mogao koristiti i **proveriti** da li je **registrovan** ili samo proveriti da li bilo koji **IP** koristi taj domen.
 
-### Pronalaženje sumnjivih domena
+### Finding suspicious domains
 
-Za ovu svrhu možete koristiti bilo koji od sledećih alata. Imajte na umu da će ovi alati takođe automatski izvršiti DNS zahteve da provere da li domen ima dodeljen neki IP:
+Za ovu svrhu možete koristiti bilo koji od sledećih alata. Imajte na umu da će ovi alati takođe automatski izvršavati DNS zahteve da provere da li domen ima dodeljen neki IP:
 
 - [**dnstwist**](https://github.com/elceef/dnstwist)
 - [**urlcrazy**](https://github.com/urbanadventurer/urlcrazy)
 
+Savet: Ako generišete listu kandidata, ubacite je i u logove vašeg DNS resolvera kako biste otkrili **NXDOMAIN upite iz vaše organizacije** (korisnici koji pokušavaju da dosegnu tipfeler pre nego što napadač zapravo registruje domen). Sinkholujte ili preblokirajte ove domene ako politika dozvoljava.
+
 ### Bitflipping
 
-**Možete pronaći kratko objašnjenje ove tehnike na roditeljskoj stranici. Ili pročitajte originalno istraživanje na** [**https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/**](https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/)
+**Kratko objašnjenje ove tehnike možete naći na roditeljskoj stranici. Ili pročitajte originalno istraživanje na** [**https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/**](https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/)
 
-Na primer, 1 bit modifikacija u domenu microsoft.com može ga transformisati u _windnws.com._\
-**Napadači mogu registrovati što više domena sa bit-flipping-om koji su povezani sa žrtvom kako bi preusmerili legitimne korisnike na svoju infrastrukturu**.
+Na primer, 1-bitna izmena u domenu microsoft.com može ga transformisati u _windnws.com._\
+**Napadači mogu registrovati što više bit-flipping domena povezanih sa žrtvom kako bi preusmerili legitimne korisnike na svoju infrastrukturu**.
 
-**Svi mogući nazivi domena sa bit-flipping-om takođe bi trebali biti praćeni.**
+**Svi mogući bit-flipping nazivi domena takođe bi trebalo da budu praćeni.**
 
-### Osnovne provere
+Ako takođe treba da uzmete u obzir homoglyph/IDN lookalikes (npr. mešanje Latin/Cyrillic karaktera), proverite:
 
-Kada imate listu potencijalno sumnjivih imena domena, trebali biste ih **proveriti** (pretežno portove HTTP i HTTPS) da **vidite da li koriste neki obrazac za prijavu sličan** nekom od domena žrtve.\
-Takođe možete proveriti port 3333 da vidite da li je otvoren i da li pokreće instancu `gophish`.\
-Takođe je zanimljivo znati **koliko je stara svaka otkrivena sumnjiva domena**, što je mlađa, to je rizičnija.\
-Možete takođe dobiti **screenshot-ove** sumnjive web stranice HTTP i/ili HTTPS da vidite da li je sumnjiva i u tom slučaju **pristupiti joj da biste je detaljnije pregledali**.
+{{#ref}}
+homograph-attacks.md
+{{#endref}}
 
-### Napredne provere
+### Basic checks
 
-Ako želite da idete korak dalje, preporučujem vam da **pratite te sumnjive domene i povremeno tražite više** (svakog dana? to traje samo nekoliko sekundi/minuta). Takođe biste trebali **proveriti** otvorene **portove** povezanih IP-ova i **tražiti instance `gophish` ili slične alate** (da, napadači takođe prave greške) i **pratiti HTTP i HTTPS web stranice sumnjivih domena i poddomena** da vidite da li su kopirali neki obrazac za prijavu sa web stranica žrtve.\
-Da biste **automatizovali ovo**, preporučujem da imate listu obrazaca za prijavu domena žrtve, da pretražujete sumnjive web stranice i upoređujete svaki obrazac za prijavu pronađen unutar sumnjivih domena sa svakim obrascem za prijavu domena žrtve koristeći nešto poput `ssdeep`.\
-Ako ste locirali obrasce za prijavu sumnjivih domena, možete pokušati da **pošaljete lažne kredencijale** i **proverite da li vas preusmerava na domen žrtve**.
+Kada imate listu potencijalno sumnjivih imena domena treba da ih **proverite** (uglavnom portove HTTP i HTTPS) da biste videli da li koriste neki login form sličan nekom iz domena žrtve.\
+Takođe možete proveriti port 3333 da vidite da li je otvoren i pokreće instancu `gophish`.\
+Zanimljivo je znati **koliko je stara svaki otkriveni sumnjiv domen** — što je mlađi, to je rizičniji.\
+Takođe možete dobiti **snimke ekrana** HTTP i/ili HTTPS sumnjive web stranice da vidite da li je sumnjiva i u tom slučaju **pristupiti joj radi dublje analize**.
 
-## Imena domena koristeći ključne reči
+### Advanced checks
 
-Roditeljska stranica takođe pominje tehniku varijacije imena domena koja se sastoji od stavljanja **imena domena žrtve unutar većeg domena** (npr. paypal-financial.com za paypal.com).
+Ako želite da odete korak dalje preporučio bih da **nadgledate te sumnjive domene i povremeno tražite nove** (svakog dana? to traje samo nekoliko sekundi/minuta). Takođe bi trebalo da **proverite** otvorene **portove** povezanih IP-ova i **tražite instance `gophish` ili sličnih alata** (da, napadači takođe greše) i **nadgledate HTTP i HTTPS web stranice sumnjivih domena i poddomena** da biste videli da li su kopirali neki login form sa stranica žrtve.\
+Da biste to **automatizovali** preporučujem da imate listu login formi domena žrtve, da pokrenete spider nad sumnjivim web stranicama i upoređujete svaki login form pronađen na sumnjivim domenima sa svakim login formom žrtvinog domena koristeći nešto poput `ssdeep`.\
+Ako ste locirali login forme sumnjivih domena, možete pokušati da **pošaljete lažne kredencijale** i **proverite da li vas preusmerava na domen žrtve**.
 
-### Transparentnost sertifikata
+---
 
-Nije moguće primeniti prethodni pristup "Brute-Force", ali je zapravo **moguće otkriti takve phishing pokušaje** takođe zahvaljujući transparentnosti sertifikata. Svaki put kada sertifikat izda CA, detalji se objavljuju. To znači da čitanjem transparentnosti sertifikata ili čak njenim praćenjem, **može se pronaći domene koje koriste ključnu reč unutar svog imena**. Na primer, ako napadač generiše sertifikat za [https://paypal-financial.com](https://paypal-financial.com), gledajući sertifikat moguće je pronaći ključnu reč "paypal" i znati da se koristi sumnjivi email.
+### Hunting by favicon and web fingerprints (Shodan/ZoomEye/Censys)
 
-Post [https://0xpatrik.com/phishing-domains/](https://0xpatrik.com/phishing-domains/) sugeriše da možete koristiti Censys da tražite sertifikate koji utiču na određenu ključnu reč i filtrirate po datumu (samo "novi" sertifikati) i po CA izdavaču "Let's Encrypt":
+Mnogi phishing kitovi ponovo koriste favicon-e iz brenda koji impersoniraju. Internet-wide skeneri izračunavaju MurmurHash3 od base64-encoded favicon-a. Možete generisati hash i pivotirati na njega:
+
+Primer u Pythonu (mmh3):
+```python
+import base64, requests, mmh3
+url = "https://www.paypal.com/favicon.ico"  # change to your brand icon
+b64 = base64.encodebytes(requests.get(url, timeout=10).content)
+print(mmh3.hash(b64))  # e.g., 309020573
+```
+- Upit na Shodan: `http.favicon.hash:309020573`
+- Sa alatima: pogledajte community tools poput favfreak za generisanje hashes i dorks za Shodan/ZoomEye/Censys.
+
+Napomene
+- Favicons se ponovo koriste; tretirajte podudaranja kao tragove i verifikujte sadržaj i certs pre nego što reagujete.
+- Kombinujte sa domain-age i heuristikom ključnih reči za veću preciznost.
+
+### Lov na URL telemetriju (urlscan.io)
+
+`urlscan.io` čuva istorijske snimke ekrana, DOM, requests i TLS meta-podatke poslatih URL-ova. Možete tražiti zloupotrebu brenda i klonove:
+
+Primeri upita (UI ili API):
+- Find lookalikes excluding your legit domains: `page.domain:(/.*yourbrand.*/ AND NOT yourbrand.com AND NOT www.yourbrand.com)`
+- Find sites hotlinking your assets: `domain:yourbrand.com AND NOT page.domain:yourbrand.com`
+- Restrict to recent results: append `AND date:>now-7d`
+
+Primer API-ja:
+```bash
+# Search recent scans mentioning your brand
+curl -s 'https://urlscan.io/api/v1/search/?q=page.domain:(/.*yourbrand.*/%20AND%20NOT%20yourbrand.com)%20AND%20date:>now-7d' \
+-H 'API-Key: <YOUR_URLSCAN_KEY>' | jq '.results[].page.url'
+```
+Iz JSON-a, pivot on:
+- `page.tlsIssuer`, `page.tlsValidFrom`, `page.tlsAgeDays` da otkriješ veoma nove certs za lookalikes
+- `task.source` values like `certstream-suspicious` da povežeš nalaze sa CT monitoringom
+
+### Starost domena preko RDAP-a (scriptable)
+
+RDAP vraća mašinski čitljive događaje o kreiranju. Korisno za označavanje **novoregistrovanih domena (NRDs)**.
+```bash
+# .com/.net RDAP (Verisign)
+curl -s https://rdap.verisign.com/com/v1/domain/suspicious-example.com | \
+jq -r '.events[] | select(.eventAction=="registration") | .eventDate'
+
+# Generic helper using rdap.net redirector
+curl -s https://www.rdap.net/domain/suspicious-example.com | jq
+```
+Obogatite svoj pipeline označavanjem domena prema starosti registracije (npr. <7 dana, <30 dana) i prioritizujte trijažu u skladu s tim.
+
+### TLS/JAx otisci prstiju za otkrivanje AiTM infrastrukture
+
+Savremeni credential-phishing sve češće koristi **Adversary-in-the-Middle (AiTM)** reverse proxy-e (npr. Evilginx) za krađu session tokena. Možete dodati detekcije na mrežnoj strani:
+
+- Zabeležite TLS/HTTP otiske (JA3/JA4/JA4S/JA4H) na egressu. Neki Evilginx buildovi su primećeni sa stabilnim JA4 vrednostima klijent/server. Alarmirajte na poznato-loše otiske samo kao slab signal i uvek potvrdite sa sadržajem i domain intel-om.
+- Proaktivno beležite TLS certificate metadata (issuer, SAN count, wildcard use, validity) za lookalike hostove otkrivene putem CT ili urlscan i korelirajte sa starošću DNS-a i geolokacijom.
+
+> Napomena: tretirajte otiske kao enrichment, ne kao jedine blokere; frameworks se razvijaju i mogu randomizovati ili obfuskovati.
+
+### Domain names using keywords
+
+Roditeljska stranica takođe pominje tehniku varijacije naziva domena koja se sastoji od ubacivanja **domena žrtve u veći domen** (npr. paypal-financial.com za paypal.com).
+
+#### Certificate Transparency
+
+Nije moguće primeniti prethodni "Brute-Force" pristup, ali je zapravo **moguće otkriti takve phishing pokušaje** zahvaljujući certificate transparency. Svaki put kada CA izda sertifikat, detalji postaju javni. To znači da čitanjem certificate transparency ili čak praćenjem istog, **moguće je pronaći domene koji koriste ključnu reč u svom imenu**. Na primer, ako napadač generiše sertifikat za [https://paypal-financial.com](https://paypal-financial.com), pregledajući sertifikat moguće je naći ključnu reč "paypal" i znati da se koristi sumnjiv e-mail.
+
+The post [https://0xpatrik.com/phishing-domains/](https://0xpatrik.com/phishing-domains/) suggests that you can use Censys to search for certificates affecting a specific keyword and filter by date (only "new" certificates) and by the CA issuer "Let's Encrypt":
 
 ![https://0xpatrik.com/content/images/2018/07/cert_listing.png](<../../images/image (1115).png>)
 
-Međutim, možete učiniti "isto" koristeći besplatni web [**crt.sh**](https://crt.sh). Možete **tražiti ključnu reč** i **filtrirati** rezultate **po datumu i CA** ako želite.
+Međutim, isto možete uraditi koristeći besplatni web [**crt.sh**](https://crt.sh). Možete **pretražiti ključnu reč** i **filtrirati** rezultate **po datumu i CA** ako želite.
 
 ![](<../../images/image (519).png>)
 
-Korišćenjem ove poslednje opcije možete čak koristiti polje Matching Identities da vidite da li se neka identitet iz pravog domena poklapa sa bilo kojim od sumnjivih domena (imajte na umu da sumnjivi domen može biti lažno pozitivan).
+Koristeći ovu poslednju opciju možete čak koristiti polje Matching Identities da vidite da li neka identitet iz pravog domena odgovara nekom od sumnjivih domena (imajte na umu da sumnjiv domen može biti false positive).
 
-**Još jedna alternativa** je fantastičan projekat pod nazivom [**CertStream**](https://medium.com/cali-dog-security/introducing-certstream-3fc13bb98067). CertStream pruža real-time tok novoregistrovanih sertifikata koje možete koristiti za otkrivanje određenih ključnih reči u (neposrednom) realnom vremenu. U stvari, postoji projekat pod nazivom [**phishing_catcher**](https://github.com/x0rz/phishing_catcher) koji to upravo radi.
+**Još jedna alternativa** je fantastičan projekat pod nazivom [**CertStream**](https://medium.com/cali-dog-security/introducing-certstream-3fc13bb98067). CertStream obezbeđuje real-time stream novo-generisanih sertifikata koji možete koristiti za detekciju određenih ključnih reči u (near) real-time. Zapravo, postoji projekat [**phishing_catcher**](https://github.com/x0rz/phishing_catcher) koji radi upravo to.
 
-### **Novi domeni**
+Praktičan savet: pri trijaži CT hitova, prioritizujte NRD-ove, nepoverljive/unknown registrare, privacy-proxy WHOIS, i certs sa vrlo nedavnim `NotBefore` vremenima. Održavajte allowlistu vaših owned domena/brandova da smanjite šum.
 
-**Jedna poslednja alternativa** je da prikupite listu **novoregistrovanih domena** za neke TLD-ove ([Whoxy](https://www.whoxy.com/newly-registered-domains/) pruža takvu uslugu) i **proverite ključne reči u tim domenima**. Međutim, dugi domeni obično koriste jedan ili više poddomena, stoga ključna reč neće biti prisutna unutar FLD-a i nećete moći pronaći phishing poddomen.
+#### **New domains**
+
+**Jedna poslednja alternativa** je da prikupite listu **newly registered domains** za neke TLD-ove ([Whoxy](https://www.whoxy.com/newly-registered-domains/) provides such service) i **proverite ključne reči u tim domenima**. Međutim, dugi domeni obično koriste jedan ili više subdomena, stoga ključna reč neće biti u FLD-u i nećete moći da pronađete phishing subdomen.
+
+Dodatna heuristika: tretirajte određene **file-extension TLDs** (npr. `.zip`, `.mov`) sa dodatnim stepenom sumnje pri alertovanju. Oni se često mešaju sa imenima fajlova u mamcima; kombinujte TLD signal sa brand ključnim rečima i NRD age za bolju preciznost.
+
+## References
+
+- urlscan.io – Search API reference: https://urlscan.io/docs/search/
+- APNIC Blog – JA4+ network fingerprinting (includes Evilginx example): https://blog.apnic.net/2023/11/22/ja4-network-fingerprinting/
 
 {{#include ../../banners/hacktricks-training.md}}

theme/ht_searcher.js

@@ -24,13 +24,15 @@
     /* 2 — load a single index (remote → local) */
     async function loadIndex(remote, local, isCloud=false){
       let rawLoaded = false;
-      try {
-        const r = await fetch(remote,{mode:'cors'});
-        if (!r.ok) throw new Error('HTTP '+r.status);
-        importScripts(URL.createObjectURL(new Blob([await r.text()],{type:'application/javascript'})));
-        rawLoaded = true;
-      } catch(e){ console.warn('remote',remote,'failed →',e); }
-      if(!rawLoaded){
+      if(remote){
+        try {
+          const r = await fetch(remote,{mode:'cors'});
+          if (!r.ok) throw new Error('HTTP '+r.status);
+          importScripts(URL.createObjectURL(new Blob([await r.text()],{type:'application/javascript'})));
+          rawLoaded = true;
+        } catch(e){ console.warn('remote',remote,'failed →',e); }
+      }
+      if(!rawLoaded && local){
         try { importScripts(abs(local)); rawLoaded = true; }
         catch(e){ console.error('local',local,'failed →',e); }
       }
@@ -40,13 +42,41 @@
       return data;
     }
 
+    async function loadWithFallback(remotes, local, isCloud=false){
+      if(remotes.length){
+        const [primary, ...secondary] = remotes;
+        const primaryData = await loadIndex(primary, null, isCloud);
+        if(primaryData) return primaryData;
+
+        if(local){
+          const localData = await loadIndex(null, local, isCloud);
+          if(localData) return localData;
+        }
+
+        for (const remote of secondary){
+          const data = await loadIndex(remote, null, isCloud);
+          if(data) return data;
+        }
+      }
+
+      return local ? loadIndex(null, local, isCloud) : null;
+    }
+
     (async () => {
-      const MAIN_RAW  = 'https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/refs/heads/master/searchindex.js';
-      const CLOUD_RAW = 'https://raw.githubusercontent.com/HackTricks-wiki/hacktricks-cloud/refs/heads/master/searchindex.js';
+      const htmlLang = (document.documentElement.lang || 'en').toLowerCase();
+      const lang = htmlLang.split('-')[0];
+      const mainReleaseBase = 'https://github.com/HackTricks-wiki/hacktricks/releases/download';
+      const cloudReleaseBase = 'https://github.com/HackTricks-wiki/hacktricks-cloud/releases/download';
+
+      const mainTags = Array.from(new Set([`searchindex-${lang}`, 'searchindex-en', 'searchindex-master']));
+      const cloudTags = Array.from(new Set([`searchindex-${lang}`, 'searchindex-en', 'searchindex-master']));
+
+      const MAIN_REMOTE_SOURCES  = mainTags.map(tag => `${mainReleaseBase}/${tag}/searchindex.js`);
+      const CLOUD_REMOTE_SOURCES = cloudTags.map(tag => `${cloudReleaseBase}/${tag}/searchindex.js`);
 
       const indices = [];
-      const main = await loadIndex(MAIN_RAW , '/searchindex.js',        false); if(main)  indices.push(main);
-      const cloud= await loadIndex(CLOUD_RAW, '/searchindex-cloud.js',  true ); if(cloud) indices.push(cloud);
+      const main = await loadWithFallback(MAIN_REMOTE_SOURCES , '/searchindex.js',        false); if(main)  indices.push(main);
+      const cloud= await loadWithFallback(CLOUD_REMOTE_SOURCES, '/searchindex-cloud.js',  true ); if(cloud) indices.push(cloud);
 
       if(!indices.length){ postMessage({ready:false, error:'no-index'}); return; }