AWS CloudHSM Offload SSL/TLS su Linux utilizzando NGINX o con OpenSSL Provider HAProxy - AWS CloudHSM
Panoramica di1: Prerequisiti2: Genera chiave e certificato3: Configura il server web4: verifica

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à.

AWS CloudHSM Offload SSL/TLS su Linux utilizzando NGINX o con OpenSSL Provider HAProxy

Questo argomento fornisce step-by-step istruzioni per configurare l'offload dell'identità SSL/TLS del server AWS CloudHSM su un server Web Linux utilizzando NGINX o con HAProxy il provider OpenSSL.

Panoramica di

Su Linux, il software NGINX e il software del server HAProxyweb si integrano con OpenSSL per supportare HTTPS. Il provider AWS CloudHSM OpenSSL fornisce un'interfaccia che consente al software del server Web di utilizzare il server Web nel cluster per HSMs l'offload crittografico e l'archiviazione delle chiavi. L'OpenSSL Provider è il bridge che collega il server Web al cluster. AWS CloudHSM

Per completare questo tutorial, configurerai NGINX o utilizzerai il HAProxy provider OpenSSL AWS CloudHSM . Il tutorial mostra come fare quanto segue:

  • Installa il software del server Web su un' EC2 istanza Amazon.

  • Configura il software del server Web in modo tale che supporti HTTPS con una chiave privata archiviata nel cluster AWS CloudHSM .

  • (Facoltativo) Utilizza Amazon EC2 per creare una seconda istanza del server Web ed Elastic Load Balancing per creare un sistema di bilanciamento del carico. L'uso di un sistema di bilanciamento del carico può migliorare le prestazioni grazie alla distribuzione del carico in più server. Offre anche ridondanza e una disponibilità più elevata in caso di errore di uno o più server.

Quando sei pronto per iniziare, vai a Fase 1: configurazione dei prerequisiti.

Fase 1: configurazione dei prerequisiti

Piattaforme diverse richiedono prerequisiti diversi. Utilizza la sezione sui prerequisiti riportata di seguito corrispondente alla tua piattaforma.

Prerequisiti per AWS CloudHSM OpenSSL Provider

Per configurare l'offload dell'identità SSL/TLS del server Web con AWS CloudHSM OpenSSL Provider for Client SDK 5, è necessario quanto segue:

  • Un AWS CloudHSM cluster attivo con almeno due moduli di sicurezza hardware (HSM)

    Nota

    È possibile utilizzare un singolo cluster HSM, ma bisogna prima disabilitare la durabilità delle chiavi del client. Per ulteriori informazioni, consulta la pagina sulla gestione delle impostazioni di durabilità delle chiavi del client e la pagina sullo strumento di configurazione di Client SDK 5.

  • Un' EC2 istanza Amazon che esegue un sistema operativo Linux con il seguente software installato:

    • Un server web (NGINX o) HAProxy

    • Il provider AWS CloudHSM OpenSSL per Client SDK 5

  • Un utente di crittografia (CU) che sia proprietario e che gestisca la chiave privata del server Web sull'HSM.

Per configurare un'istanza del server Web Linux e creare un CU sull'HSM
Nota

Molti dei comandi di questa procedura richiedono privilegi elevati. Potrebbe essere necessario eseguire i comandi con sudo o come utente root a seconda della configurazione del sistema.

  1. Installa e configura AWS CloudHSM OpenSSL Provider for Client SDK 5. Per ulteriori informazioni sull'installazione di OpenSSL Provider, consulta AWS CloudHSM OpenSSL Provider for Client SDK 5.

  2. Su un'istanza EC2 Linux che ha accesso al tuo cluster, installa NGINX o il server web: HAProxy

    Amazon Linux 2023

    • NGINX

      $ yum install nginx

    • HAProxy

      $ yum install haproxy
    RHEL 9 (9.2+)

    • NGINX

      $ yum install nginx

    • HAProxy

      $ yum install haproxy
    RHEL 10 (10.0+)

    • NGINX

      $ yum install nginx

    • HAProxy

      $ yum install haproxy
    Ubuntu 24.04

    • NGINX

      $ apt install nginx

    • HAProxy

      $ apt install haproxy

  3. Usa la CLI di CloudhSM per creare un utente crittografico. Per ulteriori informazioni sulla gestione degli utenti HSM, consulta la pagina sulla gestione degli utenti HSM con la CLI di CloudHSM.

    Suggerimento

    Prendere nota del nome utente e della password del CU, perché saranno necessari più avanti per creare o importare il certificato e la chiava privata HTTPS per il server Web.

Dopo aver completato queste operazioni, andare su Passaggio 2: generare o importare una chiave privata e ottenere un certificato.

Note

Passaggio 2: generare o importare una chiave privata e ottenere un certificato

Per abilitare HTTPS, l'applicazione del server web (NGINX o HAProxy) necessita di una chiave privata e di un certificato corrispondente SSL/TLS . Per utilizzare l'identità del SSL/TLS server Web con AWS CloudHSM, è necessario archiviare la chiave privata in un HSM del cluster. AWS CloudHSM Per prima cosa genererai una chiave privata e la utilizzerai per creare una richiesta di firma del certificato (CSR). Quindi esporti una chiave privata PEM falsa dall'HSM, che è un file di chiave privata in formato PEM che contiene un riferimento alla chiave privata memorizzata nell'HSM (non è la chiave privata effettiva). Il server Web utilizza il file di chiave privata PEM falso per identificare la chiave privata sull'HSM durante l'offload dell'identità del server. SSL/TLS

Generazione di una chiave privata

Questa sezione mostra come generare una coppia di chiavi utilizzando la CLI di CloudHSM. Una volta generata una key pair all'interno dell'HSM, è possibile esportarla come file PEM falso e generare il certificato corrispondente.

Installa e configura la CLI CloudHSM

  1. Installa e configura la CLI CloudHSM.

  2. Usa il comando seguente per avviare la CLI CloudHSM.

    $ /opt/cloudhsm/bin/cloudhsm-cli interactive

  3. Eseguire il comando seguente per accedere all'HSM. Sostituiscilo <user name> con il nome utente del tuo cripto-utente

    aws-cloudhsm>login --username <user name> --role crypto-user

Generazione di una chiave privata

A seconda del caso d'uso, è possibile generare una coppia di chiavi RSA o EC. Esegui una delle seguenti operazioni:

  • Come generare una chiave privata RSA su un HSM

    Utilizza il comando key generate-asymmetric-pair rsa per generare una coppia di chiavi RSA. Questo esempio genera una coppia di chiavi RSA con un modulo di 2048, un esponente pubblico di 65537, etichetta di chiave pubblica e etichetta chiave privata ditls_rsa_pub. tls_rsa_private

    aws-cloudhsm > key generate-asymmetric-pair rsa \
--public-exponent 65537 \
--modulus-size-bits 2048 \
--public-label tls_rsa_pub \
--private-label tls_rsa_private \
--private-attributes sign=true
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x0000000000280cc8",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "rsa",
        "label": "tls_rsa_pub",
        "id": "",
        "check-value": "0x01fe6e",
        "class": "public-key",
        "encrypt": true,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": false,
        "sign": false,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 512,
        "public-exponent": "0x010001",
        "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634df6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0acac3160f0ca9725d38318b7",
        "modulus-size-bits": 2048
      }
    },
    "private_key": {
      "key-reference": "0x0000000000280cc7",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "rsa",
        "label": "tls_rsa_private",
        "id": "",
        "check-value": "0x01fe6e",
        "class": "private-key",
        "encrypt": false,
        "decrypt": true,
        "token": true,
        "always-sensitive": true,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 1217,
        "public-exponent": "0x010001",
        "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634df6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0acac3160f0ca9725d38318b7",
        "modulus-size-bits": 2048
      }
    }
  }
}

  • Come generare una chiave privata EC su un HSM

    Utilizza il comando key generate-asymmetric-pair ec per generare una coppia di chiavi EC. Questo esempio genera una coppia di chiavi EC con la prime256v1 curva (corrispondente alla NID_X9_62_prime256v1 curva), un'etichetta a chiave pubblica di tls_ec_pub e un'etichetta a chiave privata ditls_ec_private.

    aws-cloudhsm > key generate-asymmetric-pair ec \
    --curve prime256v1 \
    --public-label tls_ec_pub \
    --private-label tls_ec_private \
    --private-attributes sign=true
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x000000000012000b",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "cluster-coverage": "session"
      },
      "attributes": {
        "key-type": "ec",
        "label": "tls_ec_pub",
        "id": "",
        "check-value": "0xd7c1a7",
        "class": "public-key",
        "encrypt": false,
        "decrypt": false,
        "token": false,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": false,
        "sign": false,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 57,
        "ec-point": "0x047096513df542250a6b228fd9cb67fd0c903abc93488467681974d6f371083fce1d79da8ad1e9ede745fb9f38ac8622a1b3ebe9270556000c",
        "curve": "secp224r1"
      }
    },
"private_key": {
      "key-reference": "0x000000000012000c",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "cluster-coverage": "session"
      },
      "attributes": {
        "key-type": "ec",
        "label": "tls_ec_private",
        "id": "",
        "check-value": "0xd7c1a7",
        "class": "private-key",
        "encrypt": false,
        "decrypt": false,
        "token": false,
        "always-sensitive": true,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 122,
        "ec-point": "0x047096513df542250a6b228fd9cb67fd0c903abc93488467681974d6f371083fce1d79da8ad1e9ede745fb9f38ac8622a1b3ebe9270556000c",
        "curve": "secp224r1"
      }
    }
  }
}

Esportazione di un file di chiave privata PEM falso

Una volta che disponi di una chiave privata nell'HSM, devi esportare un file di chiave privata PEM falso. Questo file non contiene i dati della chiave effettivi, ma consente a OpenSSL Dynamic Engine di identificare la chiave privata nell'HSM, che potrà quindi essere utilizzata per creare una richiesta di firma del certificato (CSR) e firmare la CSR per creare il certificato.

Utilizzate il key generate-filecomando per esportare la chiave privata in formato PEM falso e salvarla in un file. Sostituire i valori seguenti con i propri valori.

  • <private_key_label>— Etichetta della chiave privata generata nel passaggio precedente.

  • <web_server_fake_pem.key>— Nome del file su cui verrà scritta la tua falsa chiave PEM.

aws-cloudhsm > key generate-file --encoding reference-pem --path <web_server_fake_pem.key> --filter attr.label=<private_key_label>
{
  "error_code": 0,
  "data": {
    "message": "Successfully generated key file"
  }
}

Uscire dalla CLI CloudhSM

Esegui il comando seguente per arrestare la CLI CloudHSM.

aws-cloudhsm > quit

Ora dovresti avere un nuovo file sul tuo sistema, situato nel percorso specificato <web_server_fake_pem.key> nel comando precedente. Questo file è il file della chiave privata PEM falsa.

Generazione di un certificato auto-firmato

Dopo aver generato una chiave privata PEM falsa, puoi utilizzare questo file per generare una richiesta di firma del certificato (CSR) e un certificato.

In un ambiente di produzione, per creare un certificato da una CSR in genere ci si avvale di un'autorità di certificazione, che non è invece necessaria per un ambiente di test. Se utilizzi una CA, invia loro il file CSR e usa il SSL/TLS certificato firmato che ti forniscono nel tuo server web per HTTPS.

In alternativa all'utilizzo di una CA, puoi utilizzare AWS CloudHSM OpenSSL Dynamic Engine per creare un certificato autofirmato. I certificati autofirmati non sono considerati attendibili dai browser e non devono essere utilizzati negli ambienti di produzione, ma solo negli ambienti di test.

avvertimento

È consigliabile utilizzare i certificati autofirmati solo in un ambiente di test. Per un ambiente di produzione, è consigliabile utilizzare un metodo più sicuro, ad esempio un'autorità di certificazione per creare un certificato.

Installa e configura OpenSSL Dynamic Engine

  1. Effettuare la connessione all'istanza del client.

  2. Installa il motore AWS CloudHSM dinamico OpenSSL per Client SDK 5

Generazione di un certificato

  1. Ottieni una copia del file PEM falso generato in un passaggio precedente.

  2. Crea un CSR

    Esegui il comando seguente per utilizzare AWS CloudHSM OpenSSL Dynamic Engine per creare una richiesta di firma del certificato (CSR). <web_server_fake_pem.key>Sostituiscilo con il nome del file che contiene la tua falsa chiave privata PEM. Sostituiscilo <web_server.csr> con il nome del file che contiene la tua CSR.

    Il comando req è interattivo. Ogni campo deve essere compilato Le informazioni sul campo vengono copiate SSL/TLS nel certificato.

    Nota

    La creazione di CSR non è attualmente supportata con OpenSSL Provider. È necessario utilizzare il motore OpenSSL per questo passaggio, ma le operazioni di crittografia TLS funzioneranno con il provider.

    $ openssl req -engine cloudhsm -new -key <web_server_fake_pem.key> -out <web_server.csr>

  3. Crea un certificato auto-firmato

    Esegui il seguente comando per utilizzare AWS CloudHSM OpenSSL Dynamic Engine per firmare la tua CSR con la tua chiave privata sul tuo HSM. In questo modo viene creato un certificato autofirmato. Sostituire i valori seguenti nel comando con i propri valori.

    • <web_server.csr>— Nome del file che contiene la CSR.

    • <web_server_fake_pem.key>— Nome del file che contiene la falsa chiave privata PEM.

    • <web_server.crt>— Nome del file che conterrà il certificato del server web.

    $ openssl x509 -engine cloudhsm -req -days 365 -in <web_server.csr> -signkey <web_server_fake_pem.key> -out <web_server.crt>

Dopo aver ottenuto una chiave privata e un certificato, vai aFase 3: configurazione del server Web.

Fase 3: configurazione del server Web

È possibile aggiornare la configurazione del software del server Web per utilizzare il certificato HTTPS e la chiave privata PEM fittizia corrispondente creata nella fase precedente. Ricorda di eseguire il backup dei certificati e delle chiavi esistenti prima di iniziare. Questo completerà la configurazione del software del server web Linux per l'offload dell'identità SSL/TLS del server con. AWS CloudHSM

Completa la procedura delineata in una delle seguenti sezioni.

Configurazione del server Web NGINX

Usa questa sezione per configurare NGINX con il provider OpenSSL.

Per configurare NGINX per OpenSSL Provider

  1. Effettuare la connessione all'istanza del client.

  2. Eseguire il comando seguente per creare le directory necessarie per il certificato del server Web e la falsa chiave privata PEM.

    $ mkdir -p /etc/pki/nginx/private

  3. Eseguire il comando seguente per copiare il certificato del server Web nella posizione richiesta. <web_server.crt>Sostituiscilo con il nome del certificato del tuo server web.

    $ cp <web_server.crt> /etc/pki/nginx/server.crt

  4. Eseguire il comando seguente per copiare la falsa chiave privata PEM nella posizione richiesta. Sostituiscilo <web_server_fake_pem.key> con il nome del file che contiene la tua falsa chiave privata PEM.

    $ cp <web_server_fake_pem.key> /etc/pki/nginx/private/server.key

  5. Eseguire il comando seguente per modificare la proprietà dei file in modo che l'utente denominato nginx possa leggerli.

    $ chown nginx /etc/pki/nginx/server.crt /etc/pki/nginx/private/server.key

  6. Configura OpenSSL per utilizzare il provider. AWS CloudHSM Per ulteriori informazioni sulla configurazione del provider OpenSSL, consulta AWS CloudHSM OpenSSL Provider for Client SDK 5.

    1. Individua il tuo file di configurazione OpenSSL:

      $ openssl version -d

      Dovresti vedere un output simile a:

      OPENSSLDIR: "/etc/pki/tls"

      Il file di configurazione si trova openssl.cnf in questa directory.

    2. Nota

      Non modificate direttamente il file openssl.cnf predefinito del sistema. Ciò impedisce che le operazioni OpenSSL a livello di sistema (connessioni SSH, TLS e altri servizi) vengano instradate involontariamente attraverso il provider CloudHSM.

      L'utilizzo di un file di configurazione separato consente di estendere l'utilizzo di CloudHSM Provider solo ad applicazioni specifiche che richiedono operazioni crittografiche supportate da HSM.

      Crea un nuovo file di configurazione OpenSSL con i seguenti contenuti:

      $ cat > <example-cloudhsm-openssl.cnf> << 'EOF'
## NOTE: This should point to the system default openssl config file.
# Replace /etc/pki/tls with the path to your OpenSSL configuration directory
.include </etc/pki/tls>/openssl.cnf

# Override the existing provider_section to include AWS CloudHSM OpenSSL Provider as a 3rd party OpenSSL provider
[provider_sect]
default = default_sect
# Include AWS CloudHSM CloudHSM OpenSSL provider
cloudhsm = cloudhsm_sect

[default_sect]
activate = 1

[cloudhsm_sect]
activate = 1
EOF

    3. Assicurati che la variabile di CLOUDHSM_PIN ambiente sia impostata con le credenziali del tuo utente crittografico (CU):

      $ export CLOUDHSM_PIN=<username>:<password>

    4. Imposta la variabile di OPENSSL_CONF ambiente in modo che punti al file di configurazione aggiornato e verifica che il provider sia caricato:

      $ OPENSSL_CONF=/path/to/example-cloudhsm-openssl.cnf openssl list -providers

      Dovresti vedere sia il provider predefinito che il provider CloudHSM elencati:

      OPENSSL_CONF=/path/to/example-cloudhsm-openssl.cnf openssl list -providers
Providers:
  default
    name: OpenSSL Default Provider
    version: 3.2.2
    status: active
  cloudhsm
    name: AWS CloudHSM OpenSSL Provider
    version: 5.17.0
    status: active

  7. Eseguire il comando seguente per effettuare il backup del file /etc/nginx/nginx.conf.

    $ cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.backup

  8. Aggiornamento della configurazione per NGINX.

    Nota

    Ciascun cluster può supportare un massimo di 1000 processi di lavoro NGINX su tutti i server web NGINX.

    Amazon Linux 2023

    Usare un editor di testo per modificare il file /etc/nginx/nginx.conf. Ciò potrebbe richiedere le autorizzazioni root di Linux. All'inizio del file, aggiungi le seguenti righe: 

    env CLOUDHSM_PIN;
env OPENSSL_CONF;

    Quindi aggiungi quanto segue alla sezione TLS del file:

    # Settings for a TLS enabled server.
server {
    listen       443 ssl http2 default_server;
    listen       [::]:443 ssl http2 default_server;
    server_name  _;
    root         /usr/share/nginx/html;

    ssl_certificate "/etc/pki/nginx/server.crt";
    ssl_certificate_key "/etc/pki/nginx/private/server.key";
    # It is *strongly* recommended to generate unique DH parameters for DHE ciphers
    # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048
    # ssl_dhparam "/etc/pki/nginx/dhparams.pem";
    ssl_session_cache shared:SSL:1m;
    ssl_session_timeout  10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256";
    ssl_prefer_server_ciphers off;

    # Load configuration files for the default server block.
    include /etc/nginx/default.d/*.conf;

    location / {
    }

    error_page 404 /404.html;
    location = /40x.html {
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
    }
}
    RHEL 9 (9.2+)

    Usare un editor di testo per modificare il file /etc/nginx/nginx.conf. Ciò può richiedere i permessi di root di Linux. All'inizio del file, aggiungi le seguenti righe: 

    env CLOUDHSM_PIN;
env OPENSSL_CONF;

    Quindi aggiungi quanto segue alla sezione TLS del file:

    # Settings for a TLS enabled server.
server {
    listen       443 ssl http2 default_server;
    listen       [::]:443 ssl http2 default_server;
    server_name  _;
    root         /usr/share/nginx/html;

    ssl_certificate "/etc/pki/nginx/server.crt";
    ssl_certificate_key "/etc/pki/nginx/private/server.key";
    # It is *strongly* recommended to generate unique DH parameters for DHE ciphers
    # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048
    # ssl_dhparam "/etc/pki/nginx/dhparams.pem";
    ssl_session_cache shared:SSL:1m;
    ssl_session_timeout  10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256";
    ssl_prefer_server_ciphers off;

    # Load configuration files for the default server block.
    include /etc/nginx/default.d/*.conf;

    location / {
    }

    error_page 404 /404.html;
    location = /40x.html {
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
    }
}
    RHEL 10 (10.0+)

    Usare un editor di testo per modificare il file /etc/nginx/nginx.conf. Ciò può richiedere i permessi di root di Linux. All'inizio del file, aggiungi le seguenti righe: 

    env CLOUDHSM_PIN;
env OPENSSL_CONF;

    Quindi aggiungi quanto segue alla sezione TLS del file:

    # Settings for a TLS enabled server.
server {
    listen       443 ssl http2 default_server;
    listen       [::]:443 ssl http2 default_server;
    server_name  _;
    root         /usr/share/nginx/html;

    ssl_certificate "/etc/pki/nginx/server.crt";
    ssl_certificate_key "/etc/pki/nginx/private/server.key";
    # It is *strongly* recommended to generate unique DH parameters for DHE ciphers
    # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048
    # ssl_dhparam "/etc/pki/nginx/dhparams.pem";
    ssl_session_cache shared:SSL:1m;
    ssl_session_timeout  10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256";
    ssl_prefer_server_ciphers off;

    # Load configuration files for the default server block.
    include /etc/nginx/default.d/*.conf;

    location / {
    }

    error_page 404 /404.html;
    location = /40x.html {
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
    }
}
    Ubuntu 24.04

    Usare un editor di testo per modificare il file /etc/nginx/nginx.conf. Ciò può richiedere i permessi di root di Linux. All'inizio del file, aggiungi le seguenti righe: 

    env CLOUDHSM_PIN;
env OPENSSL_CONF;

    Quindi aggiungi quanto segue alla sezione TLS del file:

    # Settings for a TLS enabled server.
server {
    listen       443 ssl http2 default_server;
    listen       [::]:443 ssl http2 default_server;
    server_name  _;
    root         /var/www/html;

    ssl_certificate "/etc/ssl/certs/server.crt";
    ssl_certificate_key "/etc/ssl/private/server.key";
    # It is *strongly* recommended to generate unique DH parameters for DHE ciphers
    # Generate them with: openssl dhparam -out /etc/ssl/certs/dhparams.pem 2048
    # ssl_dhparam "/etc/ssl/certs/dhparams.pem";
    ssl_session_cache shared:SSL:1m;
    ssl_session_timeout  10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256";
    ssl_prefer_server_ciphers off;

    # Load configuration files for the default server block.
    include /etc/nginx/default.d/*.conf;

    location / {
    }

    error_page 404 /404.html;
    location = /40x.html {
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
    }
}

    Salvare il file.

  9. Eseguire il backup del file di configurazione systemd, quindi impostare il percorso EnvironmentFile.

    Amazon Linux 2023

    1. Esegui il backup del nginx.service file:

      $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup

    2. Aprire /lib/systemd/system/nginx.service in un editor di testo. Nella sezione [Servizio], aggiungi:

      EnvironmentFile=/etc/sysconfig/nginx
    RHEL 9 (9.2+)

    1. Esegui il backup del nginx.service file:

      $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup

    2. Aprire /lib/systemd/system/nginx.service in un editor di testo. Nella sezione [Servizio], aggiungi:

      EnvironmentFile=/etc/sysconfig/nginx
    RHEL 10 (10.0+)

    1. Esegui il backup del nginx.service file:

      $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup

    2. Aprire /lib/systemd/system/nginx.service in un editor di testo. Nella sezione [Servizio], aggiungi:

      EnvironmentFile=/etc/sysconfig/nginx
    Ubuntu 24.04

    1. Esegui il backup del nginx.service file:

      $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup

    2. Aprire /lib/systemd/system/nginx.service in un editor di testo. Nella sezione [Servizio], aggiungi:

      EnvironmentFile=/etc/sysconfig/nginx

  10. Controllare se il file /etc/sysconfig/nginx esiste, quindi eseguire una delle operazioni seguenti:

    • Se il file esiste, effettuare il backup del file eseguendo il seguente comando:

      $ cp /etc/sysconfig/nginx /etc/sysconfig/nginx.backup

    • In caso contrario, aprire un editor di testo, quindi creare un file denominato nginx nella cartella /etc/sysconfig/.

  11. Configura l'ambiente NGINX.

    Amazon Linux 2023

    Come utente root di Linux, apri il /etc/sysconfig/nginx file in un editor di testo. Ad esempio, 

    vi /etc/sysconfig/nginx

    Aggiungi le credenziali Cryptography User (CU) e il percorso del tuo file di configurazione OpenSSL:

    CLOUDHSM_PIN=<CU user name>:<password>
OPENSSL_CONF=<path to example-cloudhsm-openssl.cnf>

    Sostituisci <CU user name> e <password> con le credenziali CU. Sostituisci <path to example-cloudhsm-openssl.cnf> con il percorso completo del file di configurazione in cui hai creato. Per configurare NGINX per OpenSSL Provider

    Salvare il file.

    RHEL 9 (9.2+)

    Apri il file /etc/sysconfig/nginx in un editor di testo. Ciò potrebbe richiedere le autorizzazioni root di Linux. Aggiungi le credenziali Cryptography User (CU) e il percorso del tuo file di configurazione OpenSSL:

    CLOUDHSM_PIN=<CU user name>:<password>
OPENSSL_CONF=<path to example-cloudhsm-openssl.cnf>

    Sostituisci <CU user name> e <password> con le credenziali CU. Sostituisci <path to example-cloudhsm-openssl.cnf> con il percorso completo del file di configurazione in cui hai creato. Per configurare NGINX per OpenSSL Provider

    Salvare il file.

    RHEL 10 (10.0+)

    Apri il file /etc/sysconfig/nginx in un editor di testo. Ciò potrebbe richiedere le autorizzazioni root di Linux. Aggiungi le credenziali Cryptography User (CU) e il percorso del tuo file di configurazione OpenSSL:

    CLOUDHSM_PIN=<CU user name>:<password>
OPENSSL_CONF=<path to example-cloudhsm-openssl.cnf>

    Sostituisci <CU user name> e <password> con le credenziali CU. Sostituisci <path to example-cloudhsm-openssl.cnf> con il percorso completo del file di configurazione in cui hai creato. Per configurare NGINX per OpenSSL Provider

    Salvare il file.

    Ubuntu 24.04

    Apri il file /etc/sysconfig/nginx in un editor di testo. Ciò potrebbe richiedere le autorizzazioni root di Linux. Aggiungi le credenziali Cryptography User (CU) e il percorso del tuo file di configurazione OpenSSL:

    CLOUDHSM_PIN=<CU user name>:<password>
OPENSSL_CONF=<path to example-cloudhsm-openssl.cnf>

    Sostituisci <CU user name> e <password> con le credenziali CU. Sostituisci <path to example-cloudhsm-openssl.cnf> con il percorso completo del file di configurazione in cui hai creato. Per configurare NGINX per OpenSSL Provider

    Salvare il file.

  12. Avviare il server Web NGINX.

    Amazon Linux 2023

    Arresta tutti i processi NGINX

    $ systemctl stop nginx

    Ricarica la configurazione systemd per implementare le modifiche più recenti

    $ systemctl daemon-reload

    Avvia NGINX

    $ systemctl start nginx
    RHEL 9 (9.2+)

    Interrompi qualsiasi processo NGINX in esecuzione

    $ systemctl stop nginx

    Ricarica la configurazione systemd per implementare le modifiche più recenti

    $ systemctl daemon-reload

    Avvia il processo NGINX

    $ systemctl start nginx
    RHEL 10 (10.0+)

    Interrompi qualsiasi processo NGINX in esecuzione

    $ systemctl stop nginx

    Ricarica la configurazione systemd per implementare le modifiche più recenti

    $ systemctl daemon-reload

    Avvia il processo NGINX

    $ systemctl start nginx
    Ubuntu 24.04

    Interrompi qualsiasi processo NGINX in esecuzione

    $ systemctl stop nginx

    Ricarica la configurazione systemd per implementare le modifiche più recenti

    $ systemctl daemon-reload

    Avvia il processo NGINX

    $ systemctl start nginx

Dopo aver configurato NGINX, vai a. Verifica dell'utilizzo da parte di HTTPS del certificato configurato

Configura il server web HAProxy

Usa questa sezione per configurare HAProxy con il provider OpenSSL. Gli esempi seguenti mostrano come eseguire la configurazione HAProxy con i certificati e le chiavi CloudHSM.

Per configurare HAProxy per OpenSSL Provider

  1. Esegui il backup del file di certificato combinato esistente, se esiste:

    $ cp server-combined.pem server-combined.pem.backup

  2. Crea un file di certificato combinato per HAProxy utilizzare il tuo certificato e la falsa chiave PEM di CloudHSM:

    $ cat server.crt server.key > server-combined.pem

  3. Esegui il backup della configurazione esistente: HAProxy 

    $ cp /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.backup

  4. Crea una nuova configurazione di offload TLS di CloudHSM all'indirizzo: /etc/haproxy/haproxy.cfg

    global
    daemon
    ssl-provider cloudhsm
    # It is *strongly* recommended to generate unique DH parameters
    # Generate them with: openssl dhparam -out /etc/haproxy/dhparams.pem 2048
    # ssl-dh-param-file /etc/haproxy/dhparams.pem
    ssl-default-bind-ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305
    ssl-default-bind-ciphersuites TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256
    ssl-default-bind-options ssl-min-ver TLSv1.2 no-tls-tickets

defaults
    mode http
    timeout connect 5000ms
    timeout client 50000ms
    timeout server 50000ms

frontend haproxy_frontend
    bind *:443 ssl crt /path/to/server-combined.pem
    default_backend web_servers

backend web_servers
    server web1 127.0.0.1:8080 check

    Aggiorna il percorso del certificato in modo che corrisponda alla posizione del file.

  5. Configura systemd per utilizzare un file di ambiente per HAProxy. La posizione dipende dalla distribuzione Linux in uso.

    Amazon Linux and RHEL

    Esegui il backup e modifica del file HAProxy di servizio:

    $ cp /lib/systemd/system/haproxy.service /lib/systemd/system/haproxy.service.backup

    Modifica /lib/systemd/system/haproxy.service e aggiungi la seguente riga nella sezione [Servizio]:

    EnvironmentFile=/etc/sysconfig/haproxy
    Ubuntu

    Esegui il backup e modifica del file HAProxy di servizio:

    $ cp /lib/systemd/system/haproxy.service /lib/systemd/system/haproxy.service.backup

    Modifica /lib/systemd/system/haproxy.service e aggiungi la seguente riga nella sezione [Servizio]:

    EnvironmentFile=/etc/default/haproxy

  6. Crea il file di ambiente nella posizione appropriata per il tuo sistema.

    Amazon Linux and RHEL

    Eseguite il backup del file di HAProxy ambiente, se esiste:

    $ cp /etc/sysconfig/haproxy /etc/sysconfig/haproxy.backup

    Crea il file di HAProxy ambiente /etc/sysconfig/haproxy con i seguenti contenuti:

    CLOUDHSM_PIN=<CU user name>:<password>
    Ubuntu

    Eseguite il backup del file di HAProxy ambiente, se esiste:

    $ cp /etc/default/haproxy /etc/default/haproxy.backup

    Crea il file di HAProxy ambiente /etc/default/haproxy con i seguenti contenuti:

    CLOUDHSM_PIN=<CU user name>:<password>

    Sostituisci <CU user name> e <password> con le tue credenziali CU.

  7. Ricarica la configurazione di systemd:

    $ systemctl daemon-reload

  8. Inizia HAProxy con la configurazione di offload TLS di CloudHSM:

    $ systemctl start haproxy

    Puoi anche eseguirlo HAProxy direttamente con un file di configurazione personalizzato:

    $ haproxy -f /path/to/haproxy-cloudhsm.cfg

Dopo aver configurato HAProxy, vai aVerifica dell'utilizzo da parte di HTTPS del certificato configurato.

Fase 4: abilitazione del traffico HTTPS e verifica del certificato

Dopo aver configurato il server Web per l' SSL/TLS offload con AWS CloudHSM, aggiungi l'istanza del server Web a un gruppo di sicurezza che consente il traffico HTTPS in entrata. Ciò consente ai client, come i browser Web, di stabilire una connessione HTTPS con il server Web. Quindi stabilisci una connessione HTTPS al tuo server web e verifica che stia utilizzando il certificato con cui hai configurato per l' SSL/TLS offload. AWS CloudHSM

Abilitazione delle connessioni HTTPS in entrata

Per connetterti al server Web da un client (ad esempio un browser Web), crea un gruppo di sicurezza che consenta le connessioni HTTPS in entrata. Nello specifico, deve consentire le connessioni TCP in entrata sulla porta 443. Assegna questo gruppo di sicurezza al tuo server Web.

Per creare un gruppo di sicurezza per HTTPS e assegnarlo al server Web

  1. Apri la EC2 console Amazon all'indirizzo https://console.aws.amazon.com/ec2/.

  2. Seleziona Gruppi di sicurezza nel riquadro di navigazione.

  3. Scegliere Create Security Group (Crea gruppo di sicurezza).

  4. Per Create Security Group (Crea un gruppo di sicurezza), procedere come segue:

    1. Per Security group name (Nome del gruppo di sicurezza), digitare un nome per il gruppo di sicurezza che si sta creando.

    2. (Facoltativo) Digitare una descrizione del gruppo di sicurezza in fase di creazione.

    3. Per VPC, scegli il VPC che contiene l'istanza Amazon del tuo server web. EC2

    4. Seleziona Aggiungi regola.

    5. Per Tipo, seleziona HTTPS dalla finestra a discesa.

    6. Per Origine, inserisci una posizione di origine.

    7. Scegliere Create Security Group (Crea gruppo di sicurezza).

  5. Nel riquadro di navigazione, scegliere Instances (Istanze).

  6. Seleziona la casella di controllo accanto all'istanza del server Web.

  7. Seleziona il menu a discesa Operazioni nella parte superiore della pagina. Seleziona Sicurezza, quindi Modifica gruppi di sicurezza.

  8. Per Gruppi di sicurezza associati, seleziona la casella di ricerca e scegli il gruppo di sicurezza creato per HTTPS. Quindi, scegli Aggiungi i gruppi di sicurezza.

  9. Seleziona Salva.

Verifica dell'utilizzo da parte di HTTPS del certificato configurato

Dopo aver aggiunto il server Web a un gruppo di sicurezza, puoi verificare che SSL/TLS offload utilizzi il tuo certificato autofirmato. Per farlo, puoi utilizzare un browser Web o uno strumento come OpenSSL s_client.

Per verificare l' SSL/TLS offload con un browser web

  1. Utilizza un browser Web per connetterti al server Web utilizzando il nome DNS pubblico o l'indirizzo IP del server. Accertarsi che l'URL nella barra degli indirizzi inizi con https://. Ad esempio, https://ec2-52-14-212-67.us-east-2.compute.amazonaws.com/.

    Suggerimento

    Puoi utilizzare un servizio DNS come Amazon Route 53 per indirizzare il nome di dominio del tuo sito Web (ad esempio, https://www.example.com/) al tuo server Web. Per ulteriori informazioni, consulta la sezione Routing del traffico verso un' EC2istanza Amazon nella Amazon Route 53 Developer Guide o nella documentazione del servizio DNS.

  2. Utilizza il browser Web per visualizzare il certificato del server Web. Per ulteriori informazioni, consulta gli argomenti seguenti:

    Altri browser Web potrebbero avere caratteristiche simili da utilizzare per visualizzare il certificato del server Web.

  3. Assicurati che il SSL/TLS certificato sia quello per cui hai configurato il tuo server web.

Per verificare l' SSL/TLS offload con OpenSSL s_client

  1. Esegui il seguente comando OpenSSL per connetterti al server Web tramite HTTPS. Sostituisci <server name> con il nome DNS pubblico o l'indirizzo IP del tuo server web. 

    openssl s_client -connect <server name>:443
    Suggerimento

    Puoi utilizzare un servizio DNS come Amazon Route 53 per indirizzare il nome di dominio del tuo sito Web (ad esempio, https://www.example.com/) al tuo server Web. Per ulteriori informazioni, consulta la sezione Routing del traffico verso un' EC2istanza Amazon nella Amazon Route 53 Developer Guide o nella documentazione del servizio DNS.

  2. Assicurati che il SSL/TLS certificato sia quello per cui hai configurato il tuo server web.

A questo punto disponi di un sito Web protetto con HTTPS. La chiave privata per il server Web è archiviata in un HSM nel AWS CloudHSM cluster.

Per aggiungere un sistema di bilanciamento del carico, consulta la pagina Aggiungi un sistema di bilanciamento del carico con Elastic Load Balancing AWS CloudHSM per (opzionale).