Bring Your Own Certificate Authority (BYOCA) - AWS Crittografia dei pagamenti
Panoramica diFlusso di lavoro BYOCANote aggiuntive

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

Bring Your Own Certificate Authority (BYOCA)

Per impostazione predefinita, quando è necessario un certificato a chiave pubblica per le chiavi asimmetriche (RSA, ECC) create all'interno del servizio, questi certificati vengono emessi da una AWS Payment Cryptography e da un'autorità di certificazione (CA) univoca per l'account. Ciò ha lo scopo di semplificare l'utilizzo di X.509 senza l'onere di identificare o configurare una CA o gestire le richieste di firma dei certificati (CSR).

AWS Payment Cryptography offre anche la possibilità di utilizzare la propria CA quando necessario per motivi di policy o conformità.

Panoramica di

La funzionalità BYOCA consente di utilizzare la propria Autorità di certificazione ovunque vengano utilizzati i certificati, tra cui l'import/export TR-34, RSA Unwrap e i trasferimenti di chiavi basati su ECDH. Ciò è utile quando è necessario mantenere una catena di certificati coerente all'interno dell'organizzazione o quando si lavora con partner che richiedono certificati CA specifici. L'esempio seguente illustra il flusso di lavoro BYOCA che utilizza l'esportazione di chiavi TR-34.

Le tre differenze principali rispetto al flusso di esportazione TR-34 standard sono:

  1. La chiave RSA di firma viene creata esplicitamente utilizzando. CreateKey In precedenza, veniva creata implicitamente tramite. GetParametersForExport

  2. Una nuova API GetCertificateSigningRequestcrea una richiesta di firma del certificato (CSR) che può essere firmata dalla CA esterna.

  3. L'ExportKeyAPI è estesa per consentire la fornitura di un certificato in fase di esecuzione. In precedenza, questo veniva fornito implicitamente daimport-token, che diventa un campo opzionale.

Considerazioni importanti

  • Questi esempi utilizzano chiavi RSA-2048 e racchiudono una chiave TDES-2KEY. Quando esportate AES-128, assicuratevi che tutte le chiavi siano RSA-3072 o RSA-4096.

  • L'errore più comune è che la chiave rappresentata da e non corrisponde. SigningKeyIdentifier SigningKeyCertificate

Flusso di lavoro BYOCA

I passaggi seguenti illustrano il flusso di lavoro BYOCA completo per l'esportazione TR-34.

Fase 1: Creare una chiave RSA

Innanzitutto, crea una coppia di chiavi RSA che alla fine sarà il certificato di firma KDH. Puoi aggiungere tag per identificare lo scopo della chiave.

Esempio Crea una chiave RSA per la firma
$ aws payment-cryptography create-key --exportable \
    --key-attributes KeyAlgorithm=RSA_2048,KeyUsage=TR31_S0_ASYMMETRIC_KEY_FOR_DIGITAL_SIGNATURE,KeyClass=ASYMMETRIC_KEY_PAIR,KeyModesOfUse='{Sign=True}'
{
    "Key": {
        "KeyArn": "arn:aws:payment-cryptography:us-east-1:111122223333:key/xgmq6fs6uow736uc",
        "KeyAttributes": {
            "KeyUsage": "TR31_S0_ASYMMETRIC_KEY_FOR_DIGITAL_SIGNATURE",
            "KeyClass": "ASYMMETRIC_KEY_PAIR",
            "KeyAlgorithm": "RSA_2048",
            "KeyModesOfUse": {
                "Sign": true
            }
        },
        "KeyCheckValue": "41E3723C",
        "KeyCheckValueAlgorithm": "SHA_1",
        "Enabled": true,
        "Exportable": true,
        "KeyState": "CREATE_COMPLETE",
        "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY"
    }
}

Prendi nota di KeyArn quanto ti servirà nel passaggio successivo.

Fase 2: Generazione della richiesta di firma del certificato

Genera una richiesta di firma del certificato (CSR) da firmare dalla tua CA esterna utilizzando l'GetCertificateSigningRequestAPI. L'output è un file PEM con codifica Base64. Se decodificate i contenuti in base64 e li salvate, avrete una CSR valida in formato PEM.

Esempio Genera CSR
$ aws payment-cryptography-data get-certificate-signing-request \
    --key-identifier arn:aws:payment-cryptography:us-east-1:111122223333:key/xgmq6fs6uow736uc \
    --signing-algorithm SHA512 \
    --certificate-subject '{
        "CommonName": "MyCertificateAWSUSEAST",
        "Organization": "Amazon",
        "OrganizationUnit": "PaymentCryptography",
        "Country": "US",
        "StateOrProvince": "Virginia",
        "City": "Arlington"
    }'
{
    "CertificateSigningRequest": "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0..."
}

Il CertificateSigningRequest campo contiene il CSR con codifica base64 che invierai alla tua CA per la firma.

Fase 3: Rivedi la CSR (opzionale)

Facoltativamente, puoi usare OpenSSL per esaminare i contenuti CSR e assicurarti che siano validi e come previsto.

Esempio Esamina la CSR con OpenSSL
$ echo "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0..." | base64 -d | openssl req -text

Fase 4: Firma la CSR con un'autorità di certificazione

Dopo aver generato la CSR, devi farla firmare da un'autorità di certificazione (CA). Negli ambienti di produzione, in genere si utilizza CA privata AWS l'infrastruttura CA consolidata dell'organizzazione. A scopo di test, puoi usare OpenSSL per creare un certificato autofirmato.

Usando CA privata AWS

Per firmare la CSR utilizzando CA privata AWS, prima decodifica la CSR con codifica base64 e salvala in un file, quindi utilizza l'API. IssueCertificate

Esempio Firma CSR con AWS Private CA
$ echo "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0..." | base64 -d > csr.pem

$ aws acm-pca issue-certificate \
    --certificate-authority-arn arn:aws:acm-pca:us-east-1:111122223333:certificate-authority/12345678-1234-1234-1234-123456789012 \
    --csr fileb://csr.pem \
    --signing-algorithm SHA256WITHRSA \
    --validity Value=365,Type=DAYS
{
    "CertificateArn": "arn:aws:acm-pca:us-east-1:111122223333:certificate-authority/12345678-1234-1234-1234-123456789012/certificate/abcdef1234567890"
}

Quindi recupera il certificato firmato:

Esempio Recupera il certificato firmato
$ aws acm-pca get-certificate \
    --certificate-authority-arn arn:aws:acm-pca:us-east-1:111122223333:certificate-authority/12345678-1234-1234-1234-123456789012 \
    --certificate-arn arn:aws:acm-pca:us-east-1:111122223333:certificate-authority/12345678-1234-1234-1234-123456789012/certificate/abcdef1234567890
{
    "Certificate": "-----BEGIN CERTIFICATE-----\nMIID...\n-----END CERTIFICATE-----",
    "CertificateChain": "-----BEGIN CERTIFICATE-----\nMIID...\n-----END CERTIFICATE-----"
}

Salva il contenuto del certificato per utilizzarlo nella fase di esportazione. Dovrai codificarlo in base64 quando lo fornisci all'API. ExportKey

Usare OpenSSL per i test

A scopo di test, puoi utilizzare OpenSSL per creare una CA autofirmata e firmare la CSR. Innanzitutto, crea una chiave privata CA e un certificato autofirmato:

Esempio Crea Test CA con OpenSSL
$ # Generate CA private key
openssl genrsa -out ca-key.pem 4096

$ # Create self-signed CA certificate
openssl req -new -x509 -days 3650 -key ca-key.pem -out ca-cert.pem \
    -subj "/C=US/ST=Virginia/L=Arlington/O=TestOrg/CN=Test CA"

Quindi decodifica la CSR del passaggio precedente e firmala con la tua CA di prova:

Esempio Firma CSR con OpenSSL
$ # Decode the base64-encoded CSR
echo "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0..." | base64 -d > csr.pem

$ # Sign the CSR with the CA
openssl x509 -req -in csr.pem -CA ca-cert.pem -CAkey ca-key.pem \
    -CAcreateserial -out signed-cert.pem -days 365 -sha512
Certificate request self-signature ok
subject=C=US, ST=Virginia, L=Arlington, O=Amazon, OU=PaymentCryptography, CN=MyCertificateAWSUSEAST

Il certificato firmato è ora disponibile. signed-cert.pem Dovrai codificare questo certificato in base64 quando lo fornisci all'API: ExportKey

Esempio Base64: codifica il certificato firmato
$ cat signed-cert.pem | base64 -w 0

Fase 5: Importazione del certificato CA

È necessario innanzitutto considerare attendibile qualsiasi CA utilizzata per impedire l'utilizzo di certificati arbitrari. Importa il certificato radice della tua CA esterna utilizzando l'ImportKeyAPI. Se si utilizza una CA intermedia, import-key richiamare ma specificare TrustedPublicKey invece di RootCertificatePublicKey e specificare l'ARN della CA principale.

Esempio Importa il certificato CA principale
$ aws payment-cryptography import-key --key-material='{
    "RootCertificatePublicKey": {
        "KeyAttributes": {
            "KeyAlgorithm": "RSA_4096",
            "KeyClass": "PUBLIC_KEY",
            "KeyModesOfUse": {
                "Verify": true
            },
            "KeyUsage": "TR31_S0_ASYMMETRIC_KEY_FOR_DIGITAL_SIGNATURE"
        },
        "PublicKeyCertificate": "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t..."
    }
}'
{
    "Key": {
        "KeyArn": "arn:aws:payment-cryptography:us-east-1:111122223333:key/xivpaqy7qbbm7cdw",
        "KeyAttributes": {
            "KeyUsage": "TR31_S0_ASYMMETRIC_KEY_FOR_DIGITAL_SIGNATURE",
            "KeyClass": "PUBLIC_KEY",
            "KeyAlgorithm": "RSA_4096",
            "KeyModesOfUse": {
                "Verify": true
            }
        },
        "Enabled": true,
        "KeyState": "CREATE_COMPLETE",
        "KeyOrigin": "EXTERNAL"
    }
}

Prendi nota delle CA KeyArn da utilizzare nella fase di esportazione.

Passaggio 6: Ottieni il certificato di crittografia KRD

In questo esempio, stiamo reimportando in AWS Payment Cryptography, quindi chiamiamo il servizio per ricevere un certificato a chiave pubblica KRD utilizzando l'API. GetParametersForImport In uno scenario reale, questo verrebbe fornito da un altro sistema, come un HSM, un bancomat, un terminale di pagamento o un sistema di gestione dei terminali di pagamento.

Esempio Ottieni parametri per l'importazione
$ aws payment-cryptography-data get-parameters-for-import \
    --key-material-type "TR34_KEY_BLOCK" \
    --wrapping-key-algorithm RSA_2048
{
    "WrappingKeyCertificate": "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t...",
    "WrappingKeyCertificateChain": "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t...",
    "WrappingKeyAlgorithm": "RSA_2048",
    "ImportToken": "import-token-v2rxpl6drxeptn7w",
    "ParametersValidUntilTimestamp": "2025-11-01T18:45:31.271000-07:00"
}

Passaggio 7: esporta la chiave con BYOCA

Infine, esporta la chiave utilizzando TR-34 con il tuo certificato firmato da CA utilizzando l'API. ExportKey Fornisci il certificato di firma firmato dalla tua CA esterna.

Esempio TR-34 Esportazione con BYOCA
$ aws payment-cryptography-data export-key \
    --export-key-identifier arn:aws:payment-cryptography:us-east-1:111122223333:key/iox73p5f4c4yjiod \
    --key-material '{
        "Tr34KeyBlock": {
            "CertificateAuthorityPublicKeyIdentifier": "arn:aws:payment-cryptography:us-east-1:111122223333:key/j625deyfqlwctu57",
            "SigningKeyIdentifier": "arn:aws:payment-cryptography:us-east-1:111122223333:key/xgmq6fs6uow736uc",
            "SigningKeyCertificate": "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t...",
            "KeyBlockFormat": "X9_TR34_2012",
            "WrappingKeyCertificate": "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t..."
        }
    }'
{
    "WrappedKey": {
        "WrappedKeyMaterialFormat": "TR34_KEY_BLOCK",
        "KeyMaterial": "3082055A06092A864886F70D010702A082054B30820547...",
        "KeyCheckValue": "3DCA31",
        "KeyCheckValueAlgorithm": "ANSI_X9_24"
    }
}

Il blocco chiave esportato può ora essere importato dal sistema ricevente utilizzando il processo di importazione standard TR-34.

Note aggiuntive

  • Questi esempi sono mostrati utilizzando la CLI di AWS. La stessa funzionalità è disponibile in tutti gli AWS, SDKs inclusi Java, Python, Go e Rust.

  • Se esegui il test con una CA autofirmata, puoi utilizzare OpenSSL per creare una CA di test e firmare la CSR. In produzione, utilizza l'infrastruttura CA consolidata della tua organizzazione.