awslabs/aws-security-assessment-solutionUno strumento AWS per aiutarti a creare una valutazione puntuale del tuo account AWS utilizzando Prowler.
## Soluzioni di valutazione della sicurezza self-service (v2.0)<!-- omit from toc -->
La cybersicurezza rimane un argomento molto importante e un punto di preoccupazione per molti CIO, CISO e i loro clienti. Per rispondere a queste importanti preoccupazioni, AWS ha sviluppato un insieme primario di servizi che i clienti dovrebbero utilizzare per contribuire a proteggere i propri account. Le revisioni di [Amazon GuardDuty](https://aws.amazon.com/guardduty/), [AWS Security Hub](https://aws.amazon.com/security-hub/), [AWS Config](https://aws.amazon.com/config/) e [AWS Well-Architected](https://aws.amazon.com/architecture/well-architected/?wa-lens-whitepapers.sort-by=item.additionalFields.sortDate&wa-lens-whitepapers.sort-order=desc&wa-guidance-whitepapers.sort-by=item.additionalFields.sortDate&wa-guidance-whitepapers.sort-order=desc) aiutano i clienti a mantenere una solida postura di sicurezza sui propri account AWS. Man mano che più organizzazioni si spostano verso il cloud, soprattutto se lo fanno rapidamente, e non hanno ancora implementato i servizi AWS consigliati, potrebbe esserci la necessità di condurre una valutazione di sicurezza rapida dell'ambiente cloud.
Abbiamo sviluppato una soluzione economica, facile da distribuire, sicura e veloce per fornire ai nostri clienti un report di valutazione della sicurezza. Questi report vengono generati utilizzando il progetto open source [Prowler](https://github.com/prowler-cloud/prowler). Prowler esegue una valutazione di sicurezza puntuale basata sulle best practice di AWS e può aiutare a identificare rapidamente eventuali aree di rischio potenziale nell'ambiente distribuito di un cliente. Se sei interessato a condurre queste valutazioni su base continuativa, AWS consiglia di abilitare lo standard [Foundational Security Best Practices di Security Hub](https://docs.aws.amazon.com/securityhub/latest/userguide/securityhub-standards-fsbp.html). Se sei interessato a integrare i risultati della tua valutazione Prowler con Security Hub, puoi seguire le istruzioni nella [Documentazione di Prowler](https://docs.prowler.cloud/en/latest/tutorials/aws/securityhub/).
>Nota: Prowler non è una soluzione di proprietà di AWS. I clienti dovrebbero esaminare autonomamente Prowler prima di eseguire questa soluzione. Eventuali dipendenze associate a Prowler dovrebbero essere mantenute aggiornate. Questa soluzione installa una versione bloccata di Prowler (attualmente 5.41.0) dal programma di installazione dei pacchetti pip, in modo che una modifica al formato di output di Prowler non possa interrompere una scansione senza preavviso. Per passare a una versione più recente, modifica la riga `pip3 install prowler==` in `2-sat2-codebuild-prowler.yaml`.
📕 Per istruzioni dettagliate passo-passo più approfondite, visita il modulo 2 nel [SHIP Workshop](https://catalog.us-east-1.prod.workshops.aws/workshops/3bd6e4da-265a-4c79-ab47-639b7ef23c9d/en-US/20-satv2).
## Indice<!-- omit from toc -->
- [Panoramica](#overview)
- [Parametri](#parameters)
- [Distribuzione](#deployment)
- [Scansione di un singolo account](#single-account-scan)
- [AWS CloudShell](#aws-cloudshell)
- [Distribuire la soluzione](#deploy-the-solution)
- [AWS Console](#aws-console)
- [Distribuire la soluzione](#deploy-the-solution-1)
- [Scansione multi-account](#multi-account-scan)
- [AWS CloudShell](#aws-cloudshell-1)
- [Passaggio 1: Distribuire il ruolo prerequisito](#step-1-deploy-prerequisite-role)
- [Passaggio 2: Distribuire la soluzione SATv2](#step-2-deploy-the-satv2-solution)
- [AWS Console](#aws-console-1)
- [Passaggio 1: Distribuire il ruolo prerequisito](#step-1-deploy-prerequisite-role-1)
- [Passaggio 2: Abilitare l'amministratore delegato per AWS Organizations](#step-2-enable-delegated-administrator-for-aws-organizations)
- [Passaggio 3: Distribuire la soluzione SATv2](#step-3-deploy-the-satv2-solution)
- [Esaminare i risultati](#review-the-results)
- [Dashboard SATv2 (consigliata)](#satv2-dashboard-recommended)
- [Dashboard Prowler](#prowler-dashboard)
- [Tipi di scansione](#scan-types)
- [Scansione di base](#basic-scan)
- [Scansione intermedia](#intermediate-scan)
- [Scansione completa](#full-scan)
- [Controlli dei segreti](#secrets-checks)
- [Notifiche](#notifications)
- [Riepilogo dei report](#reporting-summary)
- [Come viene costruita la tabella Athena](#how-the-athena-table-is-built)
- [Cronologia delle scansioni e duplicati](#scan-history-and-duplicates)
- [Domande frequenti (FAQ)](#frequently-asked-questions-faq)
- [Pulizia](#clean-up)
- [Sicurezza](#security)
- [Licenza](#license)
## Panoramica
La soluzione viene distribuita con [AWS CloudFormation](https://aws.amazon.com/cloudformation/). Una volta distribuita, vengono creati un progetto [AWS CodeBuild](https://aws.amazon.com/codebuild/) e un bucket [Amazon S3](https://aws.amazon.com/s3/) per archiviare i report generati da Prowler. Una funzione [AWS Lambda](https://aws.amazon.com/lambda/) viene quindi utilizzata per avviare il progetto AWS CodeBuild.
I valori predefiniti dei parametri (input dell'utente) eseguiranno una scansione di base in un singolo account. Tuttavia, puoi scegliere parametri diversi per eseguire scansioni più estese o per scansionare più account. Il processo di distribuzione richiede meno di 5 minuti per essere completato. I template AWS CloudFormation della soluzione sono forniti per la revisione in questo repository Github.
Una volta distribuito il template, il progetto CodeBuild verrà eseguito. La valutazione predefinita richiede circa 5 minuti per essere completata. Il tempo per completare una valutazione di sicurezza varia in base al numero di risorse e alle opzioni di scansione selezionate. Al termine delle valutazioni i report vengono consegnati al bucket S3 creato.
## Parametri
SATv2 può essere personalizzato aggiornando i parametri di CloudFormation. Questa sezione riassume le opzioni disponibili e fornisce un link alla sezione con maggiori informazioni.
| Parametro | Descrizione | Maggiori informazioni |
| ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- |
| ProwlerScanType | Specifica quale tipo di scansione eseguire. Selezionando full senza specificare ProwlerOptions diverse verrà eseguita una scansione completa. Per eseguire un controllo specifico, scegli Full e aggiungi -c <check> a ProwlerOptions. | [Tipi di scansione](#scan-types) |
| ExcludeSecretsChecks | Il valore predefinito è true, che salta i controlli di Prowler che cercano segreti hardcoded nel contenuto delle risorse. Imposta su false per eseguirli. | [Controlli dei segreti](#secrets-checks) |
| MultiAccountScan | Imposta su true se vuoi scansionare tutti gli account nella tua organizzazione. Devi aver distribuito il template prerequisito per fornire un ruolo, oppure specificare un ProwlerRole diverso con le autorizzazioni appropriate. | [Scansione multi-account](#multi-account-scan) |
| Reporting | Imposta su true se vuoi riepilogare i report di Prowler in un singolo csv. Questo è utile quando si scansionano più account. | [Riepilogo dei report](#reporting-summary) |
| EmailAddress | Specifica un indirizzo se vuoi ricevere un'email al completamento della valutazione. | [Notifiche](#notifications) |
| **Parametri avanzati** |
| ConcurrentAccountScans | Per le scansioni multi-account, specifica il numero di account da scansionare contemporaneamente. Questo è utile per grandi organizzazioni con molti account. Selezionando più di tre si modifica la dimensione dell'istanza CodeBuild e potrebbe comportare costi aggiuntivi. |
| CodeBuildTimeout | Imposta il timeout per il job CodeBuild. Il valore predefinito è 300 minuti (5 ore). |
| MultiAccountListOverride | Specifica un elenco di account da scansionare separati da spazi. Lasciando questo campo vuoto verranno scansionati tutti gli account nella tua organizzazione. Assicurati di aver impostato il parametro `MultiAccountScan` sopra su true se vuoi scansionare account specifici. Se non puoi fornire l'accesso delegato a ListAccount, puoi fornire il parametro MultiAccountListOverride. | [Scansione multi-account](#multi-account-scan) |
| ProwlerOptions | Specifica i parametri per Prowler. Il --role e l'ARN verranno automaticamente aggiunti alla fine dei parametri che specifichi. Questo può anche essere utilizzato per specificare un singolo controllo. | [Scansione completa](#full-scan) |
| ProwlerRole | Il ruolo che Prowler deve assumere per eseguire la scansione. Modifica questo se vuoi specificare il tuo ruolo con autorizzazioni diverse. |
## Distribuzione
Puoi utilizzare questo progetto per eseguire Prowler su più account in un'organizzazione AWS, o su un singolo account. Forniamo istruzioni per utilizzare AWS CloudShell o la console AWS. Scegli un'opzione per iniziare.
| Tipo di distribuzione | AWS CloudShell | AWS console |
| --------------- | ------------------------- | ---------------------- |
| Singolo account | [Link](#aws-cloudshell) | [Link](#aws-console) |
| Multi-account | [Link](#aws-cloudshell-1) | [Link](#aws-console-1) |
## Scansione di un singolo account
Per eseguire la soluzione di valutazione della sicurezza self-service (SATv2) su un singolo account, segui le istruzioni riportate di seguito. Puoi scegliere di utilizzare la AWS CLI o la Console AWS.
### AWS CloudShell
<details>
<summary>Mostra i passaggi</summary>
#### Distribuire la soluzione
1. Accedi al tuo account AWS.
2. Nella barra di navigazione, scegli [AWS CloudShell](https://console.aws.amazon.com/cloudshell/home).
3. Per scaricare il template CloudFormation, inserisci il seguente comando.
```bash
wget https://raw.githubusercontent.com/awslabs/aws-security-assessment-solution/main/2-sat2-codebuild-prowler.yaml
```
4. Per creare un bucket S3 per lo staging del template, inserisci i seguenti comandi. Il template è più grande di 51.200 byte, quindi CloudFormation richiede che venga caricato su S3 anziché passato inline.
```bash
TEMPLATE_BUCKET=sat2-cfn-templates-$(aws sts get-caller-identity --query Account --output text)-$AWS_REGION
aws s3 mb s3://$TEMPLATE_BUCKET --region $AWS_REGION
```
5. Per distribuire il template CloudFormation, inserisci il seguente comando. L'opzione `--s3-bucket` carica il template nel bucket prima di creare lo stack.
```bash
aws cloudformation deploy --template-file 2-sat2-codebuild-prowler.yaml \
--stack-name sat2 \
--capabilities CAPABILITY_NAMED_IAM \
--s3-bucket $TEMPLATE_BUCKET
```
6. Dopo che lo stack è stato creato, puoi eliminare il bucket di staging. Viene utilizzato solo per consegnare il template a CloudFormation.
```bash
aws s3 rb s3://$TEMPLATE_BUCKET --force
```
</details>
### AWS Console
<details>
<summary>Mostra i passaggi</summary>
#### Distribuire la soluzione
1. Scarica il template CloudFormation [2-sat2-codebuild-prowler.yaml](https://github.com/awslabs/aws-security-assessment-solution/blob/main/2-sat2-codebuild-prowler.yaml).
2. Vai alla [console AWS CloudFormation](https://console.aws.amazon.com/cloudformation).
3. Nel pannello di navigazione, scegli **Stacks**.
4. Scegli **Create stack**.
5. In Specify template, seleziona **Upload a template file**.
6. Scegli **2-sat2-codebuild-prowler.yaml** che hai scaricato nel passaggio 1.
7. Scegli **Next**.
8. Per Stack name, inserisci **sat2**.
9. Scegli **Next**.
10. Nella pagina Configure stack options, scegli **Next**.
11. Nella pagina Review SAS, seleziona la casella **I acknowledge that AWS CloudFormation might create IAM resources.** e scegli **Submit**.
</details>
## Scansione multi-account
La soluzione di valutazione della sicurezza self-service (SAT) supporta anche le scansioni multi-account. Devi distribuire un ruolo prerequisito su ogni account su cui vuoi eseguire la scansione. Per eseguire SATv2 su più account, segui le istruzioni riportate di seguito. Puoi scegliere di utilizzare la AWS CLI o la Console AWS.
Queste istruzioni presuppongono che tu abbia già i prerequisiti per le operazioni di stack set. Per maggiori informazioni, visita la [Guida utente di AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs.html).
>Nota: Gli StackSet non si applicano all'account di gestione. Per valutare l'account di gestione, distribuisci 1-sat2-member-role come Stack CloudFormation.
### AWS CloudShell
<details>
<summary>Mostra i passaggi</summary>
#### Passaggio 1: Distribuire il ruolo prerequisito
1. Accedi al tuo account di gestione AWS.
2. Nella barra di navigazione, scegli [AWS CloudShell](https://console.aws.amazon.com/cloudshell/home).
3. Identifica da quale account eseguirai la scansione Prowler. I clienti in genere utilizzano un account di strumenti di sicurezza, o un account di audit. Prendi nota dell'ID account per il parametro **ProwlerAccountID**.
4. Per scaricare il template CloudFormation, inserisci il seguente comando.
```bash
wget https://raw.githubusercontent.com/awslabs/aws-security-assessment-solution/main/1-sat2-member-roles.yaml
```
5. Distribuisci il template CloudFormation tramite CloudFormation StackSets. Aggiorna i seguenti parametri:
- Sostituisci **\<aws-account-id\>** con l'ID account da cui eseguirai Prowler.
- Sostituisci **\<region\>** con la Region in cui vuoi distribuire il template.
```bash
aws cloudformation create-stack-set --template-body file://1-sat2-member-roles.yaml \
--stack-set-name sat2-member-roles \
--permission-model SERVICE_MANAGED \
--auto-deployment Enabled=true,RetainStacksOnAccountRemoval=false \
--capabilities CAPABILITY_NAMED_IAM \
--parameters ParameterKey=ProwlerAccountID,ParameterValue=<aws-account-id> \
--region <region>
```
6. Usa il seguente comando per creare istanze di stack per ogni account nella tua organizzazione. Puoi scegliere come target una OU specifica, o la OU root. Aggiorna i seguenti parametri:
- Sostituisci **\<root-ou\>** con l'[ID root dell'organizzazione](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_org_details.html#orgs_view_root).
- Sostituisci **\<region\>** con la Region in cui vuoi distribuire il template.
```bash
aws cloudformation create-stack-instances --stack-set-name sat2-member-roles \
--deployment-targets OrganizationalUnitIds='["<root-ou>"]' \
--regions '["<region>"]' \
--operation-preferences FailureTolerancePercentage=100,MaxConcurrentPercentage=100 \
--region <region>
```
7. Determina se hai un admin delegato o una resource policy già esistente per il tuo account Prowler. È necessaria solo un'opzione e la resource policy è incoraggiata in quanto più granulare.
>Nota: Le resource policy non sono disponibili in GovCloud, quindi dovrai utilizzare un admin delegato.
7a. Il tuo account Prowler potrebbe già avere una delega. Puoi usare i seguenti comandi per verificare:
```bash
aws organizations list-delegated-administrators
```
7b. Il tuo account Prowler potrebbe già avere una resource policy. Puoi usare i seguenti comandi per verificare:
```bash
aws organizations describe-resource-policy
```
8. Se non hai un admin delegato o una resource policy puoi usare i seguenti comandi per aggiungere l'accesso appropriato.
>Nota: Se non puoi fornire l'accesso delegato a ListAccount, puoi fornire il parametro MultiAccountListOverride nel `2-sat2-codebuild-prowler template`.
>Nota: Se stai utilizzando GovCloud, usa il passaggio 8a per creare un admin delegato. Se stai utilizzando una region commerciale, usa il passaggio 8b per fornire l'accesso con privilegi minimi a ListAccounts.
8a. Usa il seguente comando per delegare un admin se non ne hai già uno. Sostituisci **\<aws-account-id\>** con l'ID account da cui eseguirai Prowler.
```bash
aws organizations register-delegated-administrator <aws-account-id>
```
8b. Usa i seguenti comandi per aggiungere una resource policy.
- Sostituisci **\<aws-account-id\>** con l'ID account da cui eseguirai Prowler.
```bash
aws organizations put-resource-policy --content \
'{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Statement",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::<aws-account-id>:root"
},
"Action": [
"organizations:ListAccounts",
"organizations:DescribeAccount",
"organizations:ListTagsForResource",
"organizations:ListParents",
"organizations:DescribeOrganizationalUnit"
],
"Resource": "*"
}
]
}'
```
>Nota: `ListParents` e `DescribeOrganizationalUnit` sono ciò che popola le colonne `account_ou_uid` e `account_ou_name` nei risultati. Omettili e il resto della scansione funziona comunque, ma quelle due colonne tornano vuote.
#### Passaggio 2: Distribuire la soluzione SATv2
>Nota: Assicurati di essere passato all'account che hai specificato per eseguire Prowler.
1. Per scaricare il template, apri AWS CloudShell nell'**account Prowler** e inserisci il seguente comando.
```bash
wget https://raw.githubusercontent.com/awslabs/aws-security-assessment-solution/main/2-sat2-codebuild-prowler.yaml
```
2. Per creare un bucket S3 per lo staging del template, inserisci i seguenti comandi. Il template è più grande di 51.200 byte, quindi CloudFormation richiede che venga caricato su S3 anziché passato inline.
```bash
TEMPLATE_BUCKET=sat2-cfn-templates-$(aws sts get-caller-identity --query Account --output text)-$AWS_REGION
aws s3 mb s3://$TEMPLATE_BUCKET --region $AWS_REGION
```
3. Per distribuire il template nell'account Prowler. Imposta **MultiAccountScan** su **true** per scansionare tutti gli account nella tua organizzazione. L'opzione `--s3-bucket` carica il template nel bucket prima di creare lo stack.
```bash
aws cloudformation deploy --template-file 2-sat2-codebuild-prowler.yaml \
--stack-name sat2-prowler \
--capabilities CAPABILITY_NAMED_IAM \
--s3-bucket $TEMPLATE_BUCKET \
--parameter-overrides MultiAccountScan=true
```
4. Dopo che lo stack è stato creato, puoi eliminare il bucket di staging. Viene utilizzato solo per consegnare il template a CloudFormation.
```bash
aws s3 rb s3://$TEMPLATE_BUCKET --force
```
</details>
### AWS Console
<details>
<summary>Mostra i passaggi</summary>#### Passaggio 1: Distribuisci il ruolo prerequisito
1. Scarica i file **1-sat2-member-roles.yaml** e **2-sat2-codebuild-prowler.yaml**.
2. Distribuisci il template CloudFormation tramite CloudFormation StackSets. Aggiorna i seguenti parametri:
- Sostituisci \<aws-account-id\> con l'ID dell'account da cui eseguirai Prowler.
- Sostituisci \<region\> con la Region in cui vuoi distribuire il template.
3. Vai alla [console AWS CloudFormation](https://console.aws.amazon.com/cloudformation).
4. Nel pannello di navigazione, scegli **StackSets**.
5. Scegli **Create StackSet**.
6. Per Permissions, lascia selezionato **Service-managed permissions**.
7. In Specify template, seleziona **Upload a template file**.
8. Scegli **1-sat2-member-roles.yaml** che hai scaricato nel passaggio 1-1.
9. Scegli **Next**.
10. Per Stack name, inserisci **sat2-member-role**.
11. Per Parameters, inserisci quanto segue:
- ProwlerAccountID - L'ID dell'account da cui eseguirai Prowler.
12. Scegli **Next**.
13. Nella pagina Configure StackSet options, scegli **Next**.
14. In Set deployment options, inserisci quanto segue:
1. Per **Deployment targets** lascia selezionato **Deploy to organization**.
2. Per **Specify regions**, scegli **us-east-1**.
3. Per **Region Concurrency**, scegli **Parallel**.
15. Scegli **Next**.
16. Nella pagina **Review**, seleziona la casella **I acknowledge that AWS CloudFormation might create IAM resources.** e scegli **Submit**.
#### Passaggio 2: Abilita l'amministratore delegato per AWS Organizations
Determina se hai già un amministratore delegato o una resource policy esistente per l'account in cui desideri distribuire Prowler. Si consiglia di eseguire Prowler dal tuo account di security tooling (Audit). Per aggiornare o verificare che l'account di audit abbia i permessi per ListAccounts, segui questi passaggi.
1. Vai alla [console AWS Organization](https://console.aws.amazon.com/organizations).
2. Nel pannello di navigazione, scegli **Settings**.
3. Per Delegated administrator for AWS Organizations, includi la seguente istruzione.
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Statement",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::<aws-account-id>:root"
},
"Action": [
"organizations:ListAccounts",
"organizations:DescribeAccount",
"organizations:ListTagsForResource",
"organizations:ListParents",
"organizations:DescribeOrganizationalUnit"
],
"Resource": "*"
}
]
}
```
>Nota: `ListParents` e `DescribeOrganizationalUnit` sono ciò che popola le colonne `account_ou_uid` e `account_ou_name` nei findings. Omettili e il resto della scansione funziona comunque, ma quelle due colonne risulteranno vuote.
#### Passaggio 3: Distribuisci la soluzione SATv2
1. Vai alla [console AWS CloudFormation](https://console.aws.amazon.com/cloudformation) nell'account da cui eseguirai lo strumento (ProwlerAccountID).
2. Nel pannello di navigazione, scegli **Stacks**.
3. Scegli **Create stack**.
4. In Specify template, seleziona **Upload a template file**.
5. Scegli **2-sat2-codebuild-prowler.yaml** che hai scaricato nel passaggio 1-1.
6. Scegli **Next**.
7. Per Stack name, inserisci **sat2-prowler**.
8. Nella sezione Parameters, per **MultiAccountScan**, seleziona **true**.
9. Puoi facoltativamente abilitare il reporting per ottenere un riepilogo di tutti gli account in un unico file csv. Per **Reporting**, seleziona **true**.
10. Scegli **Next**.
11. Nella pagina Configure stack options, scegli **Next**.
12. Nella pagina Review SAS, seleziona la casella **I acknowledge that AWS CloudFormation might create IAM resources.** e scegli **Submit**.
</details>
## Esamina i risultati
Dopo che la soluzione è stata distribuita, una funzione Lambda avvia il progetto CodeBuild. Al termine della build del progetto CodeBuild, i risultati di Prowler verranno caricati nel bucket Amazon S3 creato. Se hai configurato le [notifiche](#notifications), riceverai un'email al termine della scansione di Prowler. Se hai configurato il [reporting](#reporting-summary), avrai un file csv consolidato nella cartella /reports.
Se non hai configurato gli avvisi email, puoi monitorare l'avanzamento dalla [console CodeBuild](https://console.aws.amazon.com/codesuite/codebuild/projects).
Per esaminare i risultati, segui questi passaggi.
1. Vai alla console Amazon S3 nell'account in cui hai distribuito Prowler.
2. Seleziona il bucket che inizia con **sat2-prowler-prowlerfindingsbucket-**
3. Scegli la cartella per il formato di output che desideri, poi le cartelle `scan_date=` e `scan_time=` per l'esecuzione che vuoi esaminare.
Ogni formato di output ha la propria cartella di primo livello, e ogni esecuzione scrive in una sottocartella `scan_date=YYYY-MM-DD/scan_time=HHMMSS` al suo interno. L'orario è l'ora UTC in cui è iniziata la scansione:
```
csv/scan_date=2026-09-01/scan_time=204955/ Prowler's CSV findings, as written
html/scan_date=2026-09-01/scan_time=204955/ per-account HTML reports
json/scan_date=2026-09-01/scan_time=204955/ per-account JSON
ocsf-json/scan_date=2026-09-01/scan_time=204955/ per-account OCSF JSON
parquet/scan_date=2026-09-01/scan_time=204955/ the copy Athena queries
compliance/scan_date=2026-09-01/scan_time=204955/ compliance CSVs, when produced
reports/ consolidated CSV and dashboard
```
Ogni esecuzione ha la propria cartella, quindi eseguire di nuovo la soluzione non mescola mai nuovi findings con quelli vecchi, anche quando la esegui più di una volta nello stesso giorno. Le esecuzioni precedenti vengono conservate così puoi confrontarle.
4. Per ogni account, ci saranno 4 tipi di file (csv, html, json, json-ocsf) nel formato `prowler-output-<aws-account-id>-<datetime>`.
5. Seleziona uno degli oggetti html.
6. Scegli **Open**.
7. Si aprirà una nuova finestra con il tuo report. Puoi usare i filtri per identificare e prioritizzare i findings.
### Dashboard SATv2 (consigliata)
Se hai abilitato il reporting, una dashboard html statica sarà nella cartella di reporting.
1. Seleziona l'oggetto **satv2-dashboard.html**, scegli **Open**.
2. Seleziona il csv consolidato, scegli **Actions**, **Share with a presigned URL**.
>Nota: Non condividere il tuo presigned URL con nessuno. Un presigned URL utilizza credenziali di sicurezza per concedere un permesso a tempo limitato per scaricare gli oggetti. L'URL può essere inserito in un browser o usato da un programma per scaricare l'oggetto. Le credenziali usate dal presigned URL sono quelle dell'utente AWS che ha generato l'URL. Per maggiori informazioni, consulta Sharing objects with presigned URLs.
3. Per **number of minutes**, inserisci **1**.
4. Incolla l'URL nella pagina satv2-dashboard.html.
5. Esamina un esempio di output della dashboard in [img/satv2-dashboard.png](https://github.com/awslabs/aws-security-assessment-solution/blob/main/img/satv2-dashboard.png)
### Dashboard Prowler
Prowler ha una dashboard integrata per esaminare i risultati. Per usare la dashboard di Prowler, Prowler deve essere installato localmente e devi scaricare i risultati di Prowler localmente.
Devi avere l'AWS Command Line Interface (CLI) e credenziali valide. Per maggiori informazioni, consulta la [guida utente di AWS Command Line interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).
1. Installa Prowler. Per maggiori informazioni, consulta le [istruzioni di installazione di Prowler](https://docs.prowler.com/projects/prowler-open-source/en/latest/#installation).
```
pip install prowler
```
2. Ottieni il nome del bucket Amazon S3. Il nome del bucket è nella console CloudFormation come risorsa ProwlerFindingsBucket. In alternativa, vai alla console S3 e cerca un bucket nel formato `{stack_name}-prowlerfindingsbucket-{ID}`
3. Scarica i CSV e i dati di compliance da S3. Se non hai eseguito una scansione completa, potresti non avere i dati di compliance. Sostituisci `{bucket_name}` con il nome del tuo bucket, e `{scan_date}` e `{scan_time}` con l'esecuzione che vuoi caricare, ad esempio `2026-09-01` e `204955`. Per elencare le esecuzioni disponibili, usa `aws s3 ls s3://{bucket_name}/csv/scan_date={scan_date}/`.
```
aws s3 sync s3://{bucket_name}/compliance/scan_date={scan_date}/scan_time={scan_time}/ output/compliance/
aws s3 sync s3://{bucket_name}/csv/scan_date={scan_date}/scan_time={scan_time}/ output/
```
>Nota: Sincronizza una esecuzione alla volta. La dashboard di Prowler legge `output/*.csv` e non cerca nelle sottocartelle, quindi copiare le cartelle `scan_date=` stesse in `output/` produrrà una dashboard vuota. Caricare due esecuzioni contemporaneamente mostrerebbe ogni finding due volte.
4. Esegui la dashboard. Usa il seguente comando per eseguire la dashboard. Per impostazione predefinita, si avvierà su http://127.0.0.1:11666/.
```
prowler dashboard
```
## Tipi di scansione
Per impostazione predefinita, SAT2 eseguirà una scansione intermedia, che esegue ogni controllo di severità critica e alta. Puoi scegliere di eseguire una scansione base o completa scegliendo un valore diverso per il parametro ProwlerScanType.
Ad esempio, una scansione di un singolo account usando l'opzione di scansione intermedia userebbe questo comando:```bash
aws cloudformation deploy --template-file 2-sat2-codebuild-prowler.yaml \
--stack-name sat2-prowler \
--capabilities CAPABILITY_NAMED_IAM \
--s3-bucket $TEMPLATE_BUCKET \
--parameter-overrides ProwlerScanType=Intermediate
```
>Nota: l'opzione `--s3-bucket` è obbligatoria perché il template è più grande di 51.200 byte, il massimo che CloudFormation accetta inline. `$TEMPLATE_BUCKET` è il bucket di staging creato nei passaggi di deployment di CloudShell sopra. Si applica a ogni esempio `aws cloudformation deploy` in questo README.
I controlli vengono aggiunti frequentemente; per vedere i controlli più recenti, eseguire il comando `prowler aws --list-checks`. Di seguito è fornito un esempio per ogni livello di controllo.
### Scansione di base
Per vedere un elenco dei controlli, consultare [controlli di base](https://github.com/awslabs/aws-security-assessment-solution/blob/main/checks/basic_checks.txt).
- Controllo manuale - Mantenere aggiornati i dettagli di contatto.
- Individuare runtime Lambda obsoleti.
- Assicurarsi che CloudTrail sia abilitato in tutte le regioni
- Assicurarsi che AWS Config sia abilitato in tutte le regioni.
- Assicurarsi che nessun security group consenta l'ingresso da 0.0.0.0/0 o ::/0 verso qualsiasi porta.
- Verificare se GuardDuty è abilitato
- Assicurarsi che la policy delle password IAM richieda almeno una lettera minuscola
- Assicurarsi che la policy delle password IAM richieda almeno un numero
- Assicurarsi che la policy delle password IAM richieda almeno un simbolo
```
---
[Read more](https://github.com/awslabs/aws-security-assessment-solution)