As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# 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.
**Topics**
+ [Visão geral do](#keyexchange-byoca.overview)
+ [Fluxo de trabalho de exportação BYOCA](#keyexchange-byoca.export-workflow)
+ [Fluxo de trabalho de importação BYOCA](#keyexchange-byoca.import-workflow)
+ [Notas adicionais](#keyexchange-byoca.notes)
## 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:
1. Você cria a chave RSA com [ CreateKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html). Antes, `GetParametersForExport` ou `GetParametersForImport` criei para você.
1. A [ GetCertificateSigningRequest ](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GetCertificateSigningRequest.html) API cria uma CSR. Sua CA externa pode então assiná-la.
1. As [ ImportKey ](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html) APIs [ ExportKey ](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_ExportKey.html) 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.
**Topics**
+ [Etapa 1: criar uma chave RSA](#keyexchange-byoca.create-rsa)
+ [Etapa 2: gerar solicitação de assinatura de certificado](#keyexchange-byoca.generate-csr)
+ [Etapa 3: Analisar a CSR (opcional)](#keyexchange-byoca.review-csr)
+ [Etapa 4: assinar o CSR com uma autoridade de certificação](#keyexchange-byoca.sign-csr)
+ [Etapa 5: Importar o certificado CA](#keyexchange-byoca.import-ca)
+ [Etapa 6: Obter o certificado de criptografia KRD](#keyexchange-byoca.get-krd)
+ [Etapa 7: Exportar chave com BYOCA](#keyexchange-byoca.export-key)
### 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.
**Example 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 ](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GetCertificateSigningRequest.html) 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.
**Example 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.
**Example 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 ](https://docs.aws.amazon.com/privateca/latest/APIReference/API_IssueCertificate.html)
**Example 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:
**Example 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:
**Example 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:
**Example 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ível`signed-cert.pem`. Você precisará codificar esse certificado em base64 ao fornecê-lo à API: `ExportKey`
**Example 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 ](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html) 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.
**Example 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 ](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GetParametersForImport.html) 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.
**Example 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 ](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_ExportKey.html) API. Forneça o certificado de assinatura que foi assinado pela sua CA externa.
**Example 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.
**Topics**
+ [Etapa 1: criar uma chave RSA](#keyexchange-byoca.import-create-rsa)
+ [Etapa 2: gerar solicitação de assinatura de certificado](#keyexchange-byoca.import-generate-csr)
+ [Etapa 3: Analisar a CSR (opcional)](#keyexchange-byoca.import-review-csr)
+ [Etapa 4: assinar o CSR com uma autoridade de certificação](#keyexchange-byoca.import-sign-csr)
+ [Etapa 5: Importar o certificado CA](#keyexchange-byoca.import-ca)
+ [Etapa 6: Obter o certificado de assinatura KDH do sistema de envio](#keyexchange-byoca.import-get-kdh)
+ [Etapa 7: Importar chave com BYOCA](#keyexchange-byoca.import-key)
### 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.
**Example 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 ](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GetCertificateSigningRequest.html) 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.
**Example 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..."
}
```
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.
**Example 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 ](https://docs.aws.amazon.com/privateca/latest/APIReference/API_IssueCertificate.html)
**Example 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:
**Example 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:
**Example 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:
**Example 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ível`krd-signed-cert.pem`. Base64-encode este certificado antes de fornecê-lo à `ImportKey` API:
**Example 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 ](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html) 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.
**Example 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 ](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GetParametersForExport.html) para obter o certificado de assinatura KDH que normalmente seria fornecido pelo sistema de envio.
**Example 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.
**Example 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.