Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Verifica delle firme dei messaggi Amazon SNS
<a name="sns-verify-signature-of-message"></a>

Amazon SNS utilizza le firme dei messaggi per confermare l'autenticità dei messaggi inviati al tuo endpoint HTTP. Per garantire l'integrità dei messaggi e prevenire lo spoofing, **devi** verificare la firma prima di elaborare qualsiasi messaggio Amazon SNS.

**Quando è necessario verificare le firme di Amazon SNS?**

È necessario verificare le firme dei messaggi Amazon SNS nei seguenti scenari:
+ Quando Amazon SNS invia un messaggio di notifica al tuo endpoint HTTP (S).
+ Quando Amazon SNS invia un messaggio di conferma al tuo endpoint dopo una chiamata [https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html)o [https://docs.aws.amazon.com/sns/latest/api/API_Unsubscribe.html](https://docs.aws.amazon.com/sns/latest/api/API_Unsubscribe.html)API.

**Amazon SNS supporta due versioni di firma:**
+ SignatureVersion1 — Utilizza un SHA1 hash del messaggio.
+ SignatureVersion2 — Utilizza un SHA256 hash del messaggio. Ciò offre una maggiore sicurezza ed è l'opzione consigliata.

**Per verificare correttamente le firme dei messaggi SNS, segui queste best practice:**
+ Recupera sempre il certificato di firma utilizzando HTTPS per prevenire attacchi di intercettazione non autorizzati.
+ Verifica che il certificato sia emesso da Amazon SNS.
+ Verifica che la catena di fiducia del certificato sia valida.
+ Il certificato deve provenire da un URL firmato da SNS.
+ Non fidatevi dei certificati forniti nel messaggio senza convalida.
+ Rifiuta qualsiasi messaggio con un messaggio imprevisto `TopicArn` per evitare lo spoofing.
+ I servizi AWS SDKs per Amazon SNS forniscono una logica di convalida integrata, che riduce il rischio di implementazione errata.

# Configurazione della versione della firma dei messaggi sugli argomenti di Amazon SNS
<a name="sns-verify-signature-of-message-configure-message-signature"></a>

La configurazione della versione della firma dei messaggi sugli argomenti di Amazon SNS consente di migliorare la sicurezza e la compatibilità del processo di verifica dei messaggi.

Seleziona tra `SignatureVersion` **1** (SHA1) e `SignatureVersion` **2** (SHA256) per controllare l'algoritmo di hashing utilizzato per firmare i messaggi. **L'impostazione predefinita degli argomenti di Amazon SNS è 1. `SignatureVersion`** Puoi configurare questa impostazione utilizzando l'azione [https://docs.aws.amazon.com/sns/latest/api/API_SetTopicAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetTopicAttributes.html)API.

Utilizzate l'esempio seguente per impostare l'attributo topic `SignatureVersion` utilizzando AWS CLI:

```
aws sns set-topic-attributes \
    --topic-arn arn:aws:sns:us-east-2:123456789012:MyTopic \
    --attribute-name SignatureVersion \
    --attribute-value 2
```

# Verifica della firma di un messaggio Amazon SNS quando si utilizzano richieste basate su query HTTP
<a name="sns-verify-signature-of-message-verify-message-signature"></a>

La verifica della firma di un messaggio Amazon SNS quando si utilizzano richieste basate su query HTTP garantisce l'autenticità e l'integrità del messaggio. Questo processo conferma che il messaggio proviene da Amazon SNS e non è stato manomesso durante il transito. Analizzando il messaggio, creando la stringa corretta da firmare e convalidando la firma con una chiave pubblica affidabile, proteggi il sistema da falsificazioni e alterazioni non autorizzate dei messaggi.

1. Estrai **coppie chiave-valore** dal documento JSON nel corpo della richiesta HTTP POST inviato da Amazon SNS. **Questi campi sono necessari per costruire la stringa da firmare.**
   + `Message`
   + `Subject`(se presente)
   + `MessageId`
   + `Timestamp`
   + `TopicArn`
   + `Type`

   Esempio:

   ```
   MESSAGE_FILE="message.json"
   FIELDS=("Message" "MessageId" "Subject" "Timestamp" "TopicArn" "Type")
   ```
**Nota**  
Se un campo contiene caratteri in escape (ad esempio,`\n`), convertili nella **forma originale** per garantire una corrispondenza esatta.

1. Individua il `SigningCertURL` campo nel messaggio Amazon SNS. Questo certificato contiene la chiave pubblica necessaria per verificare la firma del messaggio. Esempio:

   ```
   SIGNING_CERT_URL=$(jq -r '.SigningCertURL' "$MESSAGE_FILE")
   ```

1. Assicurati `SigningCertURL` che provenga da un AWS dominio affidabile (ad esempio,https://sns.us-east-1.amazonaws.com). Rifiuta qualsiasi ** AWS dominio URLs esterno** per motivi di sicurezza.

1. Scarica il **certificato X.509 dall'URL fornito**. Esempio:

   ```
   curl -s "$SIGNING_CERT_URL" -o signing_cert.pem
   ```

1. Estrai la **chiave pubblica dal certificato** X.509 scaricato. La chiave pubblica consente di decrittografare la firma del messaggio e verificarne l'integrità. Esempio:

   ```
   openssl x509 -pubkey -noout -in signing_cert.pem > public_key.pem
   ```

1. Tipi di messaggi diversi richiedono coppie chiave-valore diverse nella stringa da firmare. Identifica il **tipo di messaggio** (`Type`campo nel messaggio Amazon SNS) per determinare quali coppie **chiave-valore includere**:
   + **Messaggio di notifica**: include `Message``MessageId`, `Subject` (se presente),`Timestamp`, `TopicArn` e. `Type`
   + **SubscriptionConfirmation**o **UnsubscribeConfirmation messaggio**: include`Message`, `MessageId``SubscribeURL`,`Timestamp`,`Token`,`TopicArn`, e`Type`.

1. Amazon SNS richiede che la stringa da firmare segua un ordine rigoroso e fisso di campi per la verifica. **Devono essere inclusi solo i campi esplicitamente richiesti**, non è possibile aggiungere campi aggiuntivi. I campi opzionali`Subject`, ad esempio, devono essere inclusi solo se presenti nel messaggio e devono apparire nella posizione esatta definita dall'ordine dei campi richiesto. Esempio:

   ```
   KeyNameOne\nValueOne\nKeyNameTwo\nValueTwo
   ```
**Importante**  
Non aggiungete un carattere di nuova riga alla fine della stringa.

1. Disporre le **coppie chiave-valore** in ordine di byte (alfabetico per nome della chiave).

1. Costruisci la **stringa da firmare utilizzando il seguente esempio di formato**:

   ```
   STRING_TO_SIGN=""
   for FIELD in "${FIELDS[@]}"; do
       VALUE=$(jq -r --arg field "$FIELD" '.[$field]' "$MESSAGE_FILE")
       STRING_TO_SIGN+="$FIELD\n$VALUE"
       # Append a newline after each field except the last one
       if [[ "$FIELD" != "Type" ]]; then
           STRING_TO_SIGN+="\n"
       fi
   done
   ```

   **Esempio di messaggio di notifica:**

   ```
   Message
   My Test Message
   MessageId
   4d4dc071-ddbf-465d-bba8-08f81c89da64
   Subject
   My subject
   Timestamp
   2019-01-31T04:37:04.321Z
   TopicArn
   arn:aws:sns:us-east-2:123456789012:s4-MySNSTopic-1G1WEFCOXTC0P
   Type
   Notification
   ```

   **SubscriptionConfirmation esempio:**

   ```
   Message
   Please confirm your subscription
   MessageId
   3d891288-136d-417f-bc05-901c108273ee
   SubscribeURL
   https://sns.us-east-2.amazonaws.com/...
   Timestamp
   2024-01-01T00:00:00.000Z
   Token
   abc123...
   TopicArn
   arn:aws:sns:us-east-2:123456789012:MyTopic
   Type
   SubscriptionConfirmation
   ```

1. Il `Signature` campo nel messaggio è codificato in Base64. **È necessario **decodificarlo** per confrontare la sua forma **binaria grezza** con l'hash derivato.** Esempio:

   ```
   SIGNATURE=$(jq -r '.Signature' "$MESSAGE_FILE")
   echo "$SIGNATURE" | base64 -d > signature.bin
   ```

1. Usa il `SignatureVersion` campo per selezionare l'algoritmo di hash:
   + Per `SignatureVersion` **1**, usa **SHA1**(ad esempio,`-sha1`).
   + Per `SignatureVersion` **2**, usa **SHA256**(ad esempio,`-sha256`).

1. **Per confermare l'autenticità del messaggio Amazon SNS, genera **un** hash della stringa costruita e verifica la firma utilizzando la chiave pubblica.**

   ```
   openssl dgst -sha256 -verify public_key.pem -signature signature.bin <<< "$STRING_TO_SIGN"
   ```

   Se la firma è valida, l'output è. `Verified OK` Altrimenti, l'output è`Verification Failure`.

## Script di esempio con gestione degli errori
<a name="sns-verify-signature-of-message-example"></a>

Il seguente script di esempio automatizza il processo di verifica:

```
#!/bin/bash

# Path to the local message file
MESSAGE_FILE="message.json"

# Extract the SigningCertURL and Signature from the message
SIGNING_CERT_URL=$(jq -r '.SigningCertURL' "$MESSAGE_FILE")
SIGNATURE=$(jq -r '.Signature' "$MESSAGE_FILE")

# Fetch the X.509 certificate
curl -s "$SIGNING_CERT_URL" -o signing_cert.pem

# Extract the public key from the certificate
openssl x509 -pubkey -noout -in signing_cert.pem > public_key.pem

# Define the fields to include in the string to sign
FIELDS=("Message" "MessageId" "Subject" "Timestamp" "TopicArn" "Type")

# Initialize the string to sign
STRING_TO_SIGN=""

# Iterate over the fields to construct the string to sign
for FIELD in "${FIELDS[@]}"; do
    VALUE=$(jq -r --arg field "$FIELD" '.[$field]' "$MESSAGE_FILE")
    STRING_TO_SIGN+="$FIELD\n$VALUE"
    # Append a newline after each field except the last one
    if [[ "$FIELD" != "Type" ]]; then
        STRING_TO_SIGN+="\n"
    fi
done

# Verify the signature
echo -e "$STRING_TO_SIGN" | openssl dgst -sha256 -verify public_key.pem -signature <(echo "$SIGNATURE" | base64 -d)
```