Apportez votre propre autorité de certification (BYOCA) - AWS Cryptographie des paiements
Présentation deFlux de travail BYOCARemarques supplémentaires

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Apportez votre propre autorité de certification (BYOCA)

Par défaut, lorsqu'un certificat de clé publique est nécessaire pour les clés asymétriques (RSA, ECC) créées au sein du service, ces certificats sont émis par une autorité de certification (CA) chargée de la cryptographie des AWS paiements et du compte unique. Cela vise à simplifier l'utilisation du X.509 sans avoir à identifier ou à configurer une autorité de certification ou à gérer les demandes de signature de certificats (CSR).

AWS La cryptographie des paiements permet également d'utiliser votre propre autorité de certification lorsque cela est nécessaire pour des raisons de politique ou de conformité.

Présentation de

La fonctionnalité BYOCA vous permet d'utiliser votre propre autorité de certification partout où des certificats sont utilisés, y compris l'importation/exportation TR-34, RSA Unwrap et les transferts de clés basés sur ECDH. Cela est utile lorsque vous devez maintenir une chaîne de certificats cohérente au sein de votre organisation ou lorsque vous travaillez avec des partenaires qui ont besoin de certificats CA spécifiques. L'exemple suivant illustre le flux de travail BYOCA utilisant l'exportation de clés TR-34.

Les trois principales différences par rapport au flux d'exportation standard du TR-34 sont les suivantes :

  1. La clé RSA de signature est explicitement créée à l'aide CreateKeyde. Auparavant, il était créé implicitement via GetParametersForExport.

  2. Une nouvelle API GetCertificateSigningRequestcrée une demande de signature de certificat (CSR) qui peut être signée par votre autorité de certification externe.

  3. L'ExportKeyAPI est étendue pour permettre la fourniture d'un certificat lors de l'exécution. Auparavant, ce champ était fourni implicitement parimport-token, ce qui devient un champ facultatif.

Importantes considérations

  • Ces exemples utilisent des clés RSA-2048 et encapsulent une clé TDES-2KEY. Lors de l'exportation de l'AES-128, assurez-vous que toutes les clés sont RSA-3072 ou RSA-4096.

  • L'erreur la plus courante est que les clés représentées par SigningKeyIdentifier et SigningKeyCertificate ne correspondent pas.

Flux de travail BYOCA

Les étapes suivantes illustrent le flux de travail BYOCA complet pour l'exportation du TR-34.

Étape 1 : créer une clé RSA

Tout d'abord, créez une paire de clés RSA qui sera finalement le certificat de signature KDH. Vous pouvez ajouter des balises pour identifier l'objectif de la clé.

Exemple Création d'une clé RSA pour la signature
$ 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"
    }
}

Prenez note du, KeyArn car vous en aurez besoin à l'étape suivante.

Étape 2 : générer une demande de signature de certificat

Générez une demande de signature de certificat (CSR) à signer par votre autorité de certification externe à l'aide de l'GetCertificateSigningRequestAPI. Le résultat est un fichier PEM codé en base64. Si vous décodez le contenu en base64 et que vous l'enregistrez, vous aurez un CSR valide au format PEM.

Exemple Générer un 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..."
}

Le CertificateSigningRequest champ contient le CSR codé en base64 que vous allez envoyer à votre autorité de certification pour signature.

Étape 3 : Passez en revue le CSR (facultatif)

Vous pouvez éventuellement utiliser OpenSSL pour examiner le contenu de la CSR et vous assurer qu'il est valide et conforme aux attentes.

Exemple Passez en revue la CSR avec OpenSSL
$ echo "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0..." | base64 -d | openssl req -text

Étape 4 : signer le CSR auprès d'une autorité de certification

Après avoir généré le CSR, vous devez le faire signer par une autorité de certification (CA). Dans les environnements de production, vous utilisez Autorité de certification privée AWS généralement l'infrastructure CA établie de votre entreprise. À des fins de test, vous pouvez utiliser OpenSSL pour créer un certificat auto-signé.

En utilisant Autorité de certification privée AWS

Pour signer le CSR en utilisant Autorité de certification privée AWS, décodez d'abord le CSR codé en base64 et enregistrez-le dans un fichier, puis utilisez l'API. IssueCertificate

Exemple Signez le CSR avec AWS CA privée
$ 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"
}

Récupérez ensuite le certificat signé :

Exemple Récupérez le certificat signé
$ 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-----"
}

Enregistrez le contenu du certificat pour l'utiliser lors de l'étape d'exportation. Vous devrez l'encoder en base64 lorsque vous le fournirez à l'API. ExportKey

Utilisation d'OpenSSL pour les tests

À des fins de test, vous pouvez utiliser OpenSSL pour créer une autorité de certification autosignée et signer le CSR. Créez d'abord une clé privée CA et un certificat auto-signé :

Exemple Création d'une autorité de certification de test avec 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"

Décodez ensuite le CSR de l'étape précédente et signez-le avec votre autorité de certification de test :

Exemple Signer un CSR avec 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

Le certificat signé est maintenant disponiblesigned-cert.pem. Vous devez encoder ce certificat en base64 lorsque vous le fournissez à l'API : ExportKey

Exemple Coder le certificat signé en Base64
$ cat signed-cert.pem | base64 -w 0

Étape 5 : Importer un certificat CA

Toute autorité de certification utilisée doit d'abord être fiable pour empêcher l'utilisation de certificats arbitraires. Importez le certificat racine de votre autorité de certification externe à l'aide de l'ImportKeyAPI. Si vous utilisez une autorité de certification intermédiaire, appelez import-key à nouveau mais spécifiez à la TrustedPublicKey place RootCertificatePublicKey et spécifiez l'ARN de l'autorité de certification racine.

Exemple Importer le certificat Root CA
$ 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"
    }
}

Prenez note des CA à utiliser KeyArn lors de l'étape d'exportation.

Étape 6 : Obtenir le certificat de cryptage KRD

Dans cet exemple, nous réimportons dans AWS Payment Cryptography. Nous appelons donc le service pour recevoir un certificat de clé publique KRD à l'aide de l'GetParametersForImportAPI. Dans un scénario réel, cela serait fourni par l'autre système, comme un HSM, un guichet automatique, un terminal de paiement ou un système de gestion de terminaux de paiement.

Exemple Obtenir les paramètres pour l'importation
$ 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"
}

Étape 7 : Exporter la clé avec BYOCA

Enfin, exportez la clé à l'aide du TR-34 avec votre propre certificat signé par une autorité de certification à l'aide de l'API. ExportKey Fournissez le certificat de signature signé par votre autorité de certification externe.

Exemple TR-34 Exportation avec 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"
    }
}

Le bloc-clé exporté peut désormais être importé par le système récepteur à l'aide du processus d'importation standard TR-34.

Remarques supplémentaires

  • Ces exemples sont présentés à l'aide de l'interface de ligne de commande AWS. Les mêmes fonctionnalités sont disponibles dans tous les AWS, SDKs y compris Java, Python, Go et Rust.

  • Si vous testez avec une autorité de certification autosignée, vous pouvez utiliser OpenSSL pour créer une autorité de certification de test et signer le CSR. En production, utilisez l'infrastructure CA établie de votre organisation.