Panoramica di Flusso di lavoro di esportazione BYOCA Flusso di lavoro di importazione BYOCA Note aggiuntive

BYOCA (Bring Your Own Certificate Authority)

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 semplificarne l'utilizzo X.509 senza l'onere di identificare o configurare una CA o gestire le richieste di firma dei certificati (CSR).

AWS La crittografia dei pagamenti offre anche la possibilità di utilizzare la propria CA quando è richiesta per motivi di policy o conformità.

Panoramica di

Con BYOCA, puoi utilizzare la tua CA per i trasferimenti di chiavi TR-34 import/export, RSA Unwrap ed ECDH. Usa BYOCA quando hai bisogno di una catena di certificati coerente in tutta l'organizzazione o quando i partner richiedono certificati CA specifici. Gli esempi seguenti mostrano il flusso di lavoro BYOCA per l'esportazione e l'importazione TR-34 delle chiavi. TR-34

Esistono tre differenze principali rispetto al flusso standard: TR-34

La chiave RSA viene creata con CreateKey. Prima GetParametersForExport o l'hai GetParametersForImport creata per te.
L'GetCertificateSigningRequestAPI crea un CSR. La tua CA esterna può quindi firmarlo.
Le ImportKey API ExportKey e accettano un certificato al momento della chiamata. Il token è ora opzionale.

Considerazioni importanti

Questi esempi utilizzano RSA-2048 le chiavi e racchiudono una TDES-2KEY chiave. Durante l'esportazione AES-128, assicurati che tutte le chiavi siano RSA-3072 o RSA-4096.
L'errore più comune è che la chiave rappresentata da SigningKeyIdentifier e SigningKeyCertificate non corrisponde.

Flusso di lavoro di esportazione BYOCA

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

Fasi

Fase 1: Creare una chiave RSA
Fase 2: Generazione della richiesta di firma del certificato
Fase 3: Rivedi la CSR (opzionale)
Fase 4: Firma il CSR con un'autorità di certificazione
Fase 5: Importazione del certificato CA
Fase 6: Ottieni il certificato di crittografia KRD
Passaggio 7: Esportazione della chiave con BYOCA

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 ciò che ti KeyArn 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 un CSR valido 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 l'intero file PEM, codificato in base64. Il file PEM include i marcatori e. -----BEGIN CERTIFICATE REQUEST----- -----END CERTIFICATE REQUEST----- Invia questo valore alla tua CA per la firma.

Fase 3: Rivedi la CSR (opzionale)

Facoltativamente, puoi utilizzare OpenSSL per esaminare i contenuti della CSR e assicurarti che siano validi e conformi alle aspettative.

Esempio Rivedi la CSR con OpenSSL


$ echo "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0..." | base64 -d | openssl req -text

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

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

Utilizzo CA privata AWS

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

Esempio Firma la 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 base 64 quando lo fornisci all'API. ExportKey

Usare OpenSSL per i test

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

Esempio Crea una CA di test 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 il CSR del passaggio precedente e firmalo con la tua CA di prova:

Esempio Firma la 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 base 64 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

Qualsiasi CA utilizzata deve prima essere considerata attendibile per evitare l'uso di certificati arbitrari. Importa il certificato principale della tua CA esterna utilizzando l'ImportKeyAPI. Se utilizzi una CA intermedia, richiama import-key nuovamente ma specifica TrustedPublicKey invece RootCertificatePublicKey e specifica l'ARN CA radice.

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.

Fase 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 sarebbe fornito dall'altro sistema, come un HSM, un bancomat, un terminale di pagamento o un sistema di gestione dei terminali di pagamento.

Esempio Ottieni i 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: Esportazione della chiave con BYOCA

Infine, esporta la chiave utilizzando TR-34 il tuo CA-signed certificato utilizzando l'ExportKeyAPI. Fornisci il certificato di firma firmato dalla tua CA esterna.

Esempio TR-34 Esporta 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 .

Flusso di lavoro di importazione BYOCA

I passaggi seguenti illustrano il flusso di lavoro BYOCA per l'importazione delle chiavi. TR-34 Usa questo flusso di lavoro per ricevere una chiave di AWS Payment Cryptography con il tuo certificato di crittografia CA-signed KRD (Key Receiving Device). Con l'importazione BYOCA, controlli la catena di fiducia utilizzando una CA che già gestisci.

Fasi

Fase 1: Creare una chiave RSA
Fase 2: Generazione della richiesta di firma del certificato
Fase 3: Rivedi la CSR (opzionale)
Fase 4: Firma il CSR con un'autorità di certificazione
Fase 5: Importazione del certificato CA
Passaggio 6: Ottieni il certificato di firma KDH dal sistema di invio
Fase 7: Importazione della chiave con BYOCA

Fase 1: Creare una chiave RSA

Crea una coppia di chiavi RSA da utilizzare come chiave di crittografia KRD. Questa chiave decomprime e decrittografa la chiave in ingresso durante l'importazione. TR-34 La chiave non è esportabile perché rimane all'interno del servizio come chiave di ricezione.

Esempio Crea una chiave di crittografia KRD


$ aws payment-cryptography create-key \
    --key-attributes KeyAlgorithm=RSA_2048,KeyUsage=TR31_K2_TR34_ASYMMETRIC_KEY,KeyClass=ASYMMETRIC_KEY_PAIR,KeyModesOfUse='{Unwrap=True,Decrypt=True}'


{
    "Key": {
        "KeyArn": "arn:aws:payment-cryptography:us-east-1:111122223333:key/bm7t4qv8hzk24jce",
        "KeyAttributes": {
            "KeyUsage": "TR31_K2_TR34_ASYMMETRIC_KEY",
            "KeyClass": "ASYMMETRIC_KEY_PAIR",
            "KeyAlgorithm": "RSA_2048",
            "KeyModesOfUse": {
                "Unwrap": true,
                "Decrypt": true
            }
        },
        "KeyCheckValue": "7FA29C1E",
        "KeyCheckValueAlgorithm": "SHA_1",
        "Enabled": true,
        "Exportable": false,
        "KeyState": "CREATE_COMPLETE",
        "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY"
    }
}

Annotare il valore KeyArn. Questo valore servirà nella fase successiva.

Fase 2: Generazione della richiesta di firma del certificato

Genera una richiesta di firma del certificato (CSR) per la chiave di crittografia KRD utilizzando l'GetCertificateSigningRequestAPI. L'output è un file PEM con codifica base64. Se decodificate i contenuti in base64 e li salvate, avrete un CSR valido in formato PEM.

Esempio Genera CSR per KRD Key


$ aws payment-cryptography-data get-certificate-signing-request \
    --key-identifier arn:aws:payment-cryptography:us-east-1:111122223333:key/bm7t4qv8hzk24jce \
    --signing-algorithm SHA512 \
    --certificate-subject '{
        "CommonName": "MyImportKRDCertAWSUSEAST",
        "Organization": "Amazon",
        "OrganizationUnit": "PaymentCryptography",
        "Country": "US",
        "StateOrProvince": "Virginia",
        "City": "Arlington"
    }'


{
    "CertificateSigningRequest": "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0..."
}

Fase 3: Rivedi la CSR (opzionale)

Facoltativamente, puoi utilizzare OpenSSL per esaminare i contenuti della CSR e assicurarti che siano validi e conformi alle aspettative.

Esempio Rivedi la CSR con OpenSSL


$ echo "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0..." | base64 -d | openssl req -text

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

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

Utilizzo CA privata AWS

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

Esempio Firma la CSR con AWS Private CA


$ echo "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0..." | base64 -d > krd-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://krd-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/fedcba0987654321"
}

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/fedcba0987654321


{
    "Certificate": "-----BEGIN CERTIFICATE-----\nMIID...\n-----END CERTIFICATE-----",
    "CertificateChain": "-----BEGIN CERTIFICATE-----\nMIID...\n-----END CERTIFICATE-----"
}

Salva il contenuto del certificato per utilizzarlo nella fase di importazione. Base64-encode il certificato prima di fornirlo all'ImportKeyAPI.

Usare OpenSSL per i test

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

Esempio Crea una CA di test 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 il CSR del passaggio precedente e firmalo con la tua CA di prova:

Esempio Firma la CSR con OpenSSL


$ # Decode the base64-encoded CSR
echo "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0..." | base64 -d > krd-csr.pem

$ # Sign the CSR with the CA
openssl x509 -req -in krd-csr.pem -CA ca-cert.pem -CAkey ca-key.pem \
    -CAcreateserial -out krd-signed-cert.pem -days 365 -sha512


Certificate request self-signature ok
subject=C=US, ST=Virginia, L=Arlington, O=Amazon, OU=PaymentCryptography, CN=MyImportKRDCertAWSUSEAST

Il certificato firmato è ora disponibile. krd-signed-cert.pem Base64-encode questo certificato prima di fornirlo all'ImportKeyAPI:

Esempio Base64 Codifica il certificato firmato


$ cat krd-signed-cert.pem | base64 -w 0

Fase 5: Importazione del certificato CA

Prima di utilizzare una CA, devi prima fidarti di essa. Importa il certificato principale della CA esterna utilizzando l'ImportKeyAPI. Se utilizzi una CA intermedia, richiama import-key nuovamente ma specifica TrustedPublicKey invece RootCertificatePublicKey e specifica l'ARN CA radice.

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/nqr3c5v2wp6yl8az",
        "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"
    }
}

Annota le CA KeyArn da utilizzare nella fase di importazione.

Passaggio 6: Ottieni il certificato di firma KDH dal sistema di invio

In uno scambio di TR-34 chiavi, la parte mittente (Key Distribution Host o KDH) fornisce il certificato con chiave pubblica per la firma. Questo certificato viene utilizzato per verificare la firma sul blocco di chiavi avvolto durante l'importazione, assicurando che il materiale chiave provenga da un mittente affidabile. In fase di produzione, questo certificato proviene in genere dal sistema di invio, ad esempio un HSM, un terminale di pagamento o un sistema di gestione delle chiavi, attraverso un proprio processo di distribuzione dei certificati.

In questo esempio, utilizzi la crittografia dei AWS pagamenti sia come mittente che come destinatario per mantenere i passaggi brevi. Chiama GetParametersForExport per ottenere il certificato di firma KDH che normalmente viene fornito dal sistema di invio.

Esempio Ottieni i parametri per l'esportazione


$ aws payment-cryptography-data get-parameters-for-export \
    --key-material-type "TR34_KEY_BLOCK" \
    --signing-key-algorithm RSA_2048


{
    "ExportToken": "export-token-k8sfhe2w9rjy4bx6",
    "SigningKeyCertificate": "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t...",
    "SigningKeyCertificateChain": "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t...",
    "SigningKeyAlgorithm": "RSA_2048",
    "ParametersValidUntilTimestamp": "2025-11-01T18:45:31.271000-07:00"
}

Annota la lettera ExportToken e SigningKeyCertificate da utilizzare nella fase di importazione.

Fase 7: Importazione della chiave con BYOCA

Infine, importa la chiave utilizzando TR-34 il tuo CA-signed certificato utilizzando l'ImportKeyAPI. Fornisci il certificato di crittografia KRD firmato dalla tua CA esterna.

Il RandomNonce parametro è obbligatorio quando si utilizza TR-34 2-pass. Il servizio non genera un nonce per te: è un valore esadecimale casuale che generi e deve essere lo stesso sia sul lato di invio che su quello di ricezione. Quando si utilizza 1-pass TR-34 (che si basa su un timestamp anziché su un nonce), il timestamp non deve essere futuro. Il servizio non convalida alcuna particolare freschezza (ad esempio, entro un certo numero di ore), ma puoi imporre controlli di freschezza da parte tua, se necessario.

Esempio TR-34 Importa con BYOCA


$ aws payment-cryptography import-key --key-material='{
    "Tr34KeyBlock": {
        "CertificateAuthorityPublicKeyIdentifier": "arn:aws:payment-cryptography:us-east-1:111122223333:key/nqr3c5v2wp6yl8az",
        "KeyBlockFormat": "X9_TR34_2012",
        "RandomNonce": "4997FBB4587D571F",
        "SigningKeyCertificate": "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t...",
        "WrappingKeyCertificate": "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t...",
        "WrappingKeyIdentifier": "arn:aws:payment-cryptography:us-east-1:111122223333:key/bm7t4qv8hzk24jce",
        "WrappedKeyBlock": "D0112B0AX00E0000B82679114F470F540165EDFBF407..."
    }
}'


{
    "Key": {
        "KeyArn": "arn:aws:payment-cryptography:us-east-1:111122223333:key/gwz7u3rfxd4o52sb",
        "KeyAttributes": {
            "KeyUsage": "TR31_K0_KEY_ENCRYPTION_KEY",
            "KeyClass": "SYMMETRIC_KEY",
            "KeyAlgorithm": "TDES_2KEY",
            "KeyModesOfUse": {
                "Encrypt": true,
                "Decrypt": true
            }
        },
        "KeyCheckValue": "3DCA31",
        "KeyCheckValueAlgorithm": "ANSI_X9_24",
        "Enabled": true,
        "Exportable": true,
        "KeyState": "CREATE_COMPLETE",
        "KeyOrigin": "EXTERNAL"
    }
}

La chiave è ora importata in AWS Payment Cryptography e pronta per l'uso. Il KeyOrigin campo EXTERNAL indica che la chiave proviene dall'esterno del servizio.

Note aggiuntive

Questi esempi sono mostrati utilizzando l'interfaccia a riga di comando di AWS. La stessa funzionalità è disponibile in tutti gli SDK AWS, inclusi Java, Python, Go e Rust.
Se stai eseguendo il test con una CA autofirmata, puoi usare OpenSSL per creare una CA di test e firmare la CSR. In produzione, utilizza l'infrastruttura CA consolidata della tua organizzazione.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Argomenti avanzati

Scambio di chiavi fisiche