Visão geral do Fluxo de trabalho de exportação BYOCA Fluxo de trabalho de importação BYOCA Notas adicionais

Traga sua própria autoridade de certificação (BYOCA)

Por padrão, quando um certificado de chave pública é necessário para chaves assimétricas (RSA, ECC) criadas no serviço, esses certificados são emitidos por uma Criptografia de AWS Pagamento e uma autoridade de certificação (CA) exclusiva da conta. O objetivo é simplificar o uso X.509 sem o ônus de identificar ou configurar uma CA ou gerenciar solicitações de assinatura de certificados (CSR).

AWS A criptografia de pagamento também permite usar sua própria CA quando necessário por motivos de política ou conformidade.

Visão geral do

Com o BYOCA, você pode usar sua própria CA para transferências de TR-34 import/export chaves, RSA Unwrap e ECDH. Use o BYOCA quando precisar de uma cadeia de certificados consistente em toda a sua organização ou quando os parceiros precisarem de certificados CA específicos. Os exemplos a seguir mostram o fluxo de trabalho BYOCA para TR-34 exportação e importação de TR-34 chaves.

Há três diferenças principais em relação ao TR-34 fluxo padrão:

Você cria a chave RSA com CreateKey. Antes, GetParametersForExport ou GetParametersForImport criei para você.
A GetCertificateSigningRequest API cria uma CSR. Sua CA externa pode então assiná-la.
As ImportKey APIs ExportKey e aceitam um certificado no momento da chamada. O token agora é opcional.

Considerações importantes

Esses exemplos usam RSA-2048 chaves e envolvem uma TDES-2KEY chave. Ao exportar AES-128, certifique-se de que todas as chaves sejam RSA-3072 ou RSA-4096.
O erro mais comum é que a chave representada por SigningKeyIdentifier e SigningKeyCertificate não coincide.

Fluxo de trabalho de exportação BYOCA

As etapas a seguir demonstram o fluxo de trabalho completo do BYOCA para TR-34 exportação.

Etapas

Etapa 1: criar uma chave RSA
Etapa 2: gerar solicitação de assinatura de certificado
Etapa 3: Analisar a CSR (opcional)
Etapa 4: assinar o CSR com uma autoridade de certificação
Etapa 5: Importar o certificado CA
Etapa 6: Obter o certificado de criptografia KRD
Etapa 7: Exportar chave com BYOCA

Etapa 1: criar uma chave RSA

Primeiro, crie um par de chaves RSA que, em última instância, será o certificado de assinatura KDH. Você pode adicionar tags para identificar a finalidade da chave.

exemplo Criar chave RSA para assinatura


$ 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"
    }
}

Anote o KeyArn que você precisará dele na próxima etapa.

Etapa 2: gerar solicitação de assinatura de certificado

Gere uma Solicitação de Assinatura de Certificado (CSR) para ser assinada por sua CA externa usando a GetCertificateSigningRequest API. A saída é um arquivo PEM codificado em base64. Se você decodificar o conteúdo em base64 e salvá-lo, terá uma CSR válida no formato PEM.

exemplo Gerar 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..."
}

O CertificateSigningRequest campo contém todo o arquivo PEM, codificado em base64. O arquivo PEM inclui os -----END CERTIFICATE REQUEST----- marcadores -----BEGIN CERTIFICATE REQUEST----- e. Envie esse valor para sua CA para assinatura.

Etapa 3: Analisar a CSR (opcional)

Opcionalmente, você pode usar o OpenSSL para revisar o conteúdo da CSR e garantir que ele seja válido e conforme o esperado.

exemplo Analise a CSR com o OpenSSL


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

Etapa 4: assinar o CSR com uma autoridade de certificação

Depois de gerar a CSR, você precisa que ela seja assinada por uma Autoridade Certificadora (CA). Em ambientes de produção, você normalmente CA privada da AWS usaria a infraestrutura de CA estabelecida da sua organização. Para fins de teste, você pode usar o OpenSSL para criar um certificado autoassinado.

Utilizar CA privada da AWS

Para assinar a CSR usando CA privada da AWS, primeiro decodifique a CSR codificada em base64 e salve-a em um arquivo e, em seguida, use a API. IssueCertificate

exemplo Assine CSR com CA privada da AWS


$ 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"
}

Em seguida, recupere o certificado assinado:

exemplo Recuperar certificado assinado


$ 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-----"
}

Salve o conteúdo do certificado para uso na etapa de exportação. Você precisará codificá-lo em base64 ao fornecê-lo à API. ExportKey

Usando o OpenSSL para testes

Para fins de teste, você pode usar o OpenSSL para criar uma CA autoassinada e assinar a CSR. Primeiro, crie uma chave privada da CA e um certificado autoassinado:

exemplo Crie uma CA de teste com o 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"

Em seguida, decodifique a CSR da etapa anterior e assine-a com sua CA de teste:

exemplo Assine CSR com 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

O certificado assinado está agora disponívelsigned-cert.pem. Você precisará codificar esse certificado em base64 ao fornecê-lo à API: ExportKey

exemplo Base64 Codifique o certificado assinado


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

Etapa 5: Importar o certificado CA

Qualquer CA usada precisa ser confiável primeiro para evitar que certificados arbitrários sejam usados. Importe o certificado raiz da sua CA externa usando a ImportKey API. Se estiver usando uma CA intermediária, chame import-key novamente, mas especifique TrustedPublicKey em vez RootCertificatePublicKey de especificar o ARN da CA raiz.

exemplo Importar certificado CA raiz


$ 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"
    }
}

Anote as CAs KeyArn para uso na etapa de exportação.

Etapa 6: Obter o certificado de criptografia KRD

Neste exemplo, estamos importando novamente para a criptografia de AWS pagamento, então chamamos o serviço para receber um certificado de chave pública KRD usando a API. GetParametersForImport Em um cenário real, isso seria fornecido por outro sistema, como um HSM, um caixa eletrônico, um terminal de pagamento ou um sistema de gerenciamento de terminal de pagamento.

exemplo Obter parâmetros a serem importados


$ 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"
}

Etapa 7: Exportar chave com BYOCA

Por fim, exporte a chave usando TR-34 seu próprio CA-signed certificado usando a ExportKey API. Forneça o certificado de assinatura que foi assinado pela sua CA externa.

exemplo TR-34 Exportar com 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"
    }
}

O bloco de chaves exportado agora pode ser importado pelo sistema receptor usando o processo de TR-34 importação padrão.

Fluxo de trabalho de importação BYOCA

As etapas a seguir orientam você pelo fluxo de trabalho BYOCA para importação de TR-34 chaves. Use esse fluxo de trabalho para receber uma chave na criptografia AWS de pagamento com seu próprio certificado de criptografia CA-signed KRD (Key Receiving Device). Com a importação BYOCA, você controla a cadeia de confiança usando uma CA que você já gerencia.

Etapas

Etapa 1: criar uma chave RSA
Etapa 2: gerar solicitação de assinatura de certificado
Etapa 3: Analisar a CSR (opcional)
Etapa 4: assinar o CSR com uma autoridade de certificação
Etapa 5: Importar o certificado CA
Etapa 6: Obter o certificado de assinatura KDH do sistema de envio
Etapa 7: Importar chave com BYOCA

Etapa 1: criar uma chave RSA

Crie um par de chaves RSA para usar como chave de criptografia KRD. Essa chave desembrulha e descriptografa a chave recebida durante a importação. TR-34 A chave não é exportável porque permanece no serviço como chave receptora.

exemplo Criar chave de criptografia 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"
    }
}

Observe o valor KeyArn. Você precisa dele na próxima etapa.

Etapa 2: gerar solicitação de assinatura de certificado

Gere uma Solicitação de Assinatura de Certificado (CSR) para a chave de criptografia KRD usando a GetCertificateSigningRequest API. A saída é um arquivo PEM codificado em base64. Se você decodificar o conteúdo em base64 e salvá-lo, terá uma CSR válida no formato PEM.

exemplo Gerar CSR para a chave KRD


$ 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..."
}

Etapa 3: Analisar a CSR (opcional)

Opcionalmente, você pode usar o OpenSSL para revisar o conteúdo da CSR e garantir que ele seja válido e conforme o esperado.

exemplo Analise a CSR com o OpenSSL


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

Etapa 4: assinar o CSR com uma autoridade de certificação

Depois de gerar a CSR, faça com que ela seja assinada por uma Autoridade Certificadora (CA). Em ambientes de produção, você normalmente CA privada da AWS usaria a infraestrutura de CA estabelecida da sua organização. Para fins de teste, você pode usar o OpenSSL para criar um certificado autoassinado.

Utilizar CA privada da AWS

Para assinar a CSR usando CA privada da AWS, primeiro decodifique a CSR codificada em base64 e salve-a em um arquivo e depois use a API. IssueCertificate

exemplo Assine CSR com CA privada da AWS


$ 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"
}

Em seguida, recupere o certificado assinado:

exemplo Recuperar certificado assinado


$ 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-----"
}

Salve o conteúdo do certificado para uso na etapa de importação. Base64-encode o certificado antes de fornecê-lo à ImportKey API.

Usando o OpenSSL para testes

Para fins de teste, você pode usar o OpenSSL para criar uma CA autoassinada e assinar a CSR. Primeiro, crie uma chave privada da CA e um certificado autoassinado:

exemplo Crie uma CA de teste com o 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"

Em seguida, decodifique a CSR da etapa anterior e assine-a com sua CA de teste:

exemplo Assine CSR com 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

O certificado assinado está agora disponívelkrd-signed-cert.pem. Base64-encode este certificado antes de fornecê-lo à ImportKey API:

exemplo Base64 Codifique o certificado assinado


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

Etapa 5: Importar o certificado CA

Antes de usar uma CA, você deve confiar nela primeiro. Importe o certificado raiz da sua CA externa usando a ImportKey API. Se estiver usando uma CA intermediária, chame import-key novamente, mas especifique TrustedPublicKey em vez RootCertificatePublicKey de especificar o ARN da CA raiz.

exemplo Importar certificado CA raiz


$ 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"
    }
}

Observe as CAs KeyArn para uso na etapa de importação.

Etapa 6: Obter o certificado de assinatura KDH do sistema de envio

Em uma troca de TR-34 chaves, o lado remetente (Key Distribution Host, ou KDH) fornece seu certificado de chave pública para assinatura. Esse certificado é usado para verificar a assinatura no bloco de chaves encapsulado durante a importação, garantindo que o material da chave tenha vindo de um remetente confiável. Na produção, esse certificado normalmente vem do sistema de envio, como um HSM, um terminal de pagamento ou um sistema de gerenciamento de chaves, por meio de seu próprio processo de distribuição de certificados.

Neste exemplo, você usa a criptografia AWS de pagamento como remetente e destinatário para manter as etapas curtas. Ligue GetParametersForExport para obter o certificado de assinatura KDH que normalmente seria fornecido pelo sistema de envio.

exemplo Obter parâmetros para exportação


$ 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"
}

Anote o ExportToken e SigningKeyCertificate para uso na etapa de importação.

Etapa 7: Importar chave com BYOCA

Por fim, importe a chave usando TR-34 seu próprio CA-signed certificado usando a ImportKey API. Forneça o certificado de criptografia KRD que foi assinado pela sua CA externa.

O RandomNonce parâmetro é necessário ao usar 2 passagens TR-34. O serviço não gera um nonce para você — é um valor hexadecimal aleatório que você gera e deve ser o mesmo no lado do envio e do recebimento. Ao usar 1-pass TR-34 (que depende de um carimbo de data/hora em vez de um nonce), o carimbo de data/hora não deve estar no futuro. O serviço não valida nenhuma atualização específica (por exemplo, dentro de um determinado número de horas), mas você pode impor verificações de atualização de sua parte, se necessário.

exemplo TR-34 Importe com 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"
    }
}

A chave agora está importada para a criptografia AWS de pagamento e está pronta para uso. O KeyOrigin campo mostra a EXTERNAL indicação de que a chave veio de fora do serviço.

Notas adicionais

Esses exemplos são mostrados usando o AWS CLI. A mesma funcionalidade está disponível em todos os SDKs da AWS, incluindo Java, Python, Go e Rust.
Se você estiver testando com uma CA autoassinada, poderá usar o OpenSSL para criar uma CA de teste e assinar a CSR. Na produção, use a infraestrutura de CA estabelecida da sua organização.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Tópicos avançados

Troca de chaves físicas