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 autoridade de certificação (CA) exclusiva da conta e de criptografia de AWS pagamento. O objetivo é simplificar o uso, X.509 sem a necessidade de identificar ou configurar uma CA ou gerenciar solicitações de assinatura de certificado (CSR).
AWS A criptografia de pagamento também oferece a capacidade de usar sua própria CA quando necessário por motivos de política ou conformidade.
## Visão geral do
O recurso BYOCA permite que você use sua própria Autoridade de Certificação em qualquer lugar em que os certificados sejam usados TR-34 import/export, incluindo RSA Unwrap e ECDH-based transferências de chaves. Isso é útil quando você precisa manter uma cadeia de certificados consistente em toda a organização ou ao trabalhar com parceiros que exigem certificados de CA específicos. O exemplo a seguir demonstra o fluxo de trabalho BYOCA usando a exportação de TR-34 chaves.
As três principais diferenças em relação ao fluxo de TR-34 exportação padrão são:
1. A chave RSA de assinatura é criada explicitamente usando. [CreateKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html) Anteriormente, ele foi criado implicitamente via [GetParametersForExport](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GetParametersForExport.html).
1. Uma nova API [GetCertificateSigningRequest](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GetCertificateSigningRequest.html)cria uma Solicitação de Assinatura de Certificado (CSR) que pode ser assinada por sua CA externa.
1. A [ExportKey](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_ExportKey.html)API é estendida para permitir que um certificado seja fornecido em tempo de execução. Anteriormente, isso era fornecido implicitamente por`import-token`, o que se torna um campo opcional.
**Considerações importantes**
Esses exemplos usam RSA-2048 chaves e quebram uma TDES-2KEY chave. Ao exportar AES-128, verifique se todas as chaves são RSA-3072 ou RSA-4096.
O erro mais comum é que a chave representada por `SigningKeyIdentifier` e `SigningKeyCertificate` não coincide.
## Fluxo de trabalho BYOCA
As etapas a seguir demonstram o fluxo de trabalho completo do BYOCA para TR-34 exportação.
**Topics**
+ [Etapa 1: Criar chave RSA](#keyexchange-byoca.create-rsa)
+ [Etapa 2: gerar solicitação de assinatura de certificado](#keyexchange-byoca.generate-csr)
+ [Etapa 3: revisar a CSR (opcional)](#keyexchange-byoca.review-csr)
+ [Etapa 4: Assine o CSR com uma autoridade de certificação](#keyexchange-byoca.sign-csr)
+ [Etapa 5: Importar 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 chave RSA
Primeiro, crie um par de chaves RSA que, em última análise, 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á 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, você terá um CSR válido 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 a CSR codificada em base64 que você enviará à sua CA para assinatura.
### Etapa 3: revisar a CSR (opcional)
Opcionalmente, você pode usar o OpenSSL para revisar o conteúdo do 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: Assine o CSR com uma autoridade de certificação
Depois de gerar a CSR, você precisa assiná-la por uma Autoridade Certificadora (CA). Em ambientes de produção, você normalmente CA privada da AWS usaria a infraestrutura de CA estabelecida pela sua organização. Para fins de teste, você pode usar o OpenSSL para criar um certificado autoassinado.
#### Usando 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/acm-pca/latest/APIReference/API_IssueCertificate.html)
**Example Assine CSR com 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"
}
```
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 um CA de teste com 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 Codifique o certificado assinado em Base64**
```
$ cat signed-cert.pem | base64 -w 0
```
### Etapa 5: Importar 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 raiz da CA.
**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 de volta para a criptografia de AWS pagamento, então ligamos para 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 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 de recebimento usando o processo de TR-34 importação padrão.
## Notas adicionais
+ Esses exemplos são mostrados usando a 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 pela sua organização.