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á.
# Segurança em AWS Transfer Family
A segurança na nuvem AWS é a maior prioridade. Como AWS cliente, você se beneficia de uma arquitetura de data center e rede criada para atender aos requisitos das organizações mais sensíveis à segurança.
A segurança é uma responsabilidade compartilhada entre você AWS e você. O [modelo de responsabilidade compartilhada](https://aws.amazon.com/compliance/shared-responsibility-model/) descreve isto como segurança *da* nuvem e segurança *na* nuvem.
Para saber se um AWS service (Serviço da AWS) está dentro do escopo de programas de conformidade específicos, consulte [Serviços da AWS Escopo por Programa de Conformidade Serviços da AWS](https://aws.amazon.com/compliance/services-in-scope/) e escolha o programa de conformidade em que você está interessado. Para obter informações gerais, consulte Programas de [AWS conformidade Programas AWS](https://aws.amazon.com/compliance/programs/) de .
Você pode baixar relatórios de auditoria de terceiros usando AWS Artifact. Para obter mais informações, consulte [Baixar relatórios em AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html) .
Sua responsabilidade de conformidade ao usar Serviços da AWS é determinada pela confidencialidade de seus dados, pelos objetivos de conformidade de sua empresa e pelas leis e regulamentações aplicáveis. Para obter mais informações sobre sua responsabilidade de conformidade ao usar Serviços da AWS, consulte a [documentação AWS de segurança](https://docs.aws.amazon.com/security/).
Esta documentação ajuda você a entender como aplicar o modelo de responsabilidade compartilhada ao usar AWS Transfer Family. Os tópicos a seguir mostram como configurar para atender AWS Transfer Family aos seus objetivos de segurança e conformidade. Você também aprenderá a usar outros AWS serviços que ajudam a monitorar e proteger seus AWS Transfer Family recursos.
Oferecemos um workshop que fornece orientação prescritiva e um laboratório prático sobre como você pode criar uma arquitetura de transferência de arquivos escalável e segura AWS sem precisar modificar os aplicativos existentes ou gerenciar a infraestrutura do servidor. É possível ver os detalhes desse workshop [aqui](https://catalog.workshops.aws/basic-security-workshop-transfer-family/en-US).
**Topics**
+ [Benefícios da segurança da conectividade VPC](#vpc-connectivity-security)
+ [Políticas de segurança para AWS Transfer Family servidores](security-policies.md)
+ [Políticas de segurança para conectores AWS Transfer Family SFTP](security-policies-connectors.md)
+ [Usando a troca híbrida de chaves pós-quânticas com AWS Transfer Family](post-quantum-security-policies.md)
+ [Proteção e criptografia de dados](encryption-at-rest.md)
+ [Gerenciando chaves SSH e PGP no Transfer Family](key-management.md)
+ [Gerenciamento de identidade e acesso para AWS Transfer Family](security-iam.md)
+ [Validação de conformidade para AWS Transfer Family](transfer-compliance.md)
+ [Resiliência em AWS Transfer Family](disaster-recovery-resiliency.md)
+ [Crie uma conexão privada entre uma VPC e AWS Transfer Family APIs](vpc-api-endpoints.md)
+ [Segurança da infraestrutura em AWS Transfer Family](infrastructure-security.md)
+ [Adicione um firewall da aplicação web](web-application-firewall.md)
+ [Prevenção do problema do “confused deputy” entre serviços](confused-deputy.md)
+ [AWS políticas gerenciadas para AWS Transfer Family](security-iam-awsmanpol.md)
## Benefícios da segurança da conectividade VPC
Os conectores SFTP com tipo de saída VPC oferecem benefícios de segurança aprimorados por meio do acesso a recursos entre VPC:
+ **Isolamento de rede**: todo o tráfego permanece em seu ambiente de VPC, fornecendo isolamento completo da rede da Internet pública para conexões de endpoint privadas.
+ **Controle de IP de origem**: os servidores SFTP remotos só veem endereços IP do intervalo CIDR da VPC, oferecendo controle total sobre os endereços IP de origem usados nas conexões.
+ **Acesso privado ao endpoint**: conecte-se diretamente aos servidores SFTP em sua VPC usando endereços IP privados, eliminando a exposição à Internet pública.
+ **Conectividade híbrida**: acesse com segurança servidores SFTP locais por meio de conexões VPN ou Direct Connect estabelecidas sem exposição adicional à Internet.
+ **Controles de segurança da VPC**: aproveite os grupos de segurança e as políticas de roteamento da VPC existentes NACLs para controlar e monitorar o tráfego do conector SFTP.
### Modelo de segurança VPC Lattice
A conectividade VPC para conectores SFTP usa o AWS VPC Lattice com redes de serviços para fornecer acesso seguro para vários locatários:
+ **Prevenção delegada confusa**: as verificações de autenticação e autorização garantem que os conectores só possam acessar os recursos específicos para os quais estão configurados, impedindo o acesso não autorizado entre inquilinos.
+ **IPv6-rede de serviços somente**: usa IPv6 endereçamento para evitar possíveis conflitos de endereços IP e aprimorar o isolamento de segurança.
+ **Sessão de acesso direto (FAS)**: o tratamento temporário de credenciais elimina a necessidade de armazenamento de credenciais de longo prazo ou compartilhamento manual de recursos.
+ **Controle de acesso em nível de recurso**: cada conector está associado a uma configuração de recursos específica, garantindo controle de acesso granular a servidores SFTP individuais.
### Melhores práticas de segurança para conectividade VPC
Ao usar conectores do tipo de saída VPC, siga estas práticas recomendadas de segurança:
+ **Grupos de segurança**: configure grupos de segurança para permitir tráfego SFTP (porta 22) somente entre os recursos necessários. Restrinja os intervalos de IP de origem e destino ao mínimo necessário.
+ **Posicionamento do Resource Gateway**: implante gateways de recursos em sub-redes privadas sempre que possível e garanta que eles abranjam pelo menos duas zonas de disponibilidade para alta disponibilidade.
+ **Monitoramento de rede**: use o VPC Flow Logs e CloudWatch a Amazon para monitorar padrões de tráfego de rede e detectar atividades anômalas.
+ **Registro de acesso**: habilite o registro de conectores para rastrear atividades de transferência de arquivos e manter trilhas de auditoria para requisitos de conformidade.
+ **Gerenciamento de configuração de recursos**: revise e atualize regularmente as configurações de recursos para garantir que elas apontem para os servidores SFTP corretos e usem as configurações de rede apropriadas.
# Políticas de segurança para AWS Transfer Family servidores
As políticas de segurança do servidor AWS Transfer Family permitem que você limite o conjunto de algoritmos criptográficos (códigos de autenticação de mensagens (MACs), trocas de chaves (KEXs), conjuntos de cifras, cifras de criptografia de conteúdo e algoritmos de hash) associados ao seu servidor.
AWS Transfer Family suporta políticas de segurança pós-quântica que usam algoritmos híbridos de troca de chaves, combinando métodos criptográficos tradicionais com algoritmos pós-quânticos para fornecer segurança aprimorada contra futuras ameaças da computação quântica. Os detalhes são fornecidos em[Usando a troca híbrida de chaves pós-quânticas com AWS Transfer Family](post-quantum-security-policies.md).
Para ver uma lista dos algoritmos de chave suportados, consulte [Algoritmos criptográficos](#cryptographic-algorithms). Para obter uma lista de algoritmos de chave compatíveis para uso com chaves de host de servidor e chaves de usuário gerenciadas por serviços, consulte [Gerenciando chaves SSH e PGP no Transfer Family](key-management.md).
**nota**
É altamente recomendável atualizar seus servidores de acordo com nossa política de segurança mais recente.
`TransferSecurityPolicy-2024-01`é a política de segurança padrão anexada ao seu servidor ao criar um servidor usando o console, a API ou a CLI.
Se você criar um servidor Transfer Family usando CloudFormation e aceitar a política de segurança padrão, o servidor será atribuído`TransferSecurityPolicy-2018-11`.
Se você estiver preocupado com a compatibilidade do cliente, indique afirmativamente qual política de segurança você deseja usar ao criar ou atualizar um servidor, em vez de usar a política padrão, que está sujeita a alterações. Para alterar a política de segurança de um servidor, consulte[Edite a política de segurança](edit-server-config.md#edit-cryptographic-algorithm).
Para obter mais informações sobre segurança no Transfer Family, consulte as seguintes postagens no blog:
+ [Seis dicas para melhorar a segurança do seu AWS Transfer Family servidor](https://aws.amazon.com/blogs/security/six-tips-to-improve-the-security-of-your-aws-transfer-family-server/)
+ [Como a Transfer Family pode ajudar você a criar uma solução de transferência gerenciada de arquivos segura e compatível](https://aws.amazon.com/blogs/security/how-transfer-family-can-help-you-build-a-secure-compliant-managed-file-transfer-solution/)
**Topics**
+ [Algoritmos criptográficos](#cryptographic-algorithms)
+ [TransferSecurityPolicy-2024-01](#security-policy-transfer-2024-01)
+ [TransferSecurityPolicy- SshAuditCompliant -2025-02](#security-policy-transferSecurityPolicy-SshAuditCompliant-2025-02)
+ [TransferSecurityPolicy-2023-05](#security-policy-transfer-2023-05)
+ [TransferSecurityPolicy-2022-03](#security-policy-transfer-2022-03)
+ [TransferSecurityPolicy-2020-06 e -Restrito -2020-06 TransferSecurityPolicy](#security-policy-transfer-2020-06)
+ [TransferSecurityPolicy-2018-11 e -Restrito -2018-11 TransferSecurityPolicy](#security-policy-transfer-2018-11)
+ [TransferSecurityPolicy-FIPS-2024-01/ -FIPS-2024-05 TransferSecurityPolicy](#security-policy-transfer-fips-2024-01)
+ [TransferSecurityPolicy-FIPS-2023-05](#security-policy-transfer-fips-2023-05)
+ [TransferSecurityPolicy-FIPS-2020-06](#security-policy-transfer-fips-2020-06)
+ [TransferSecurityPolicy- AS2 Restrito - 2025-07](#as2-restricted-policy)
+ [Políticas de segurança Post Quantum](#pq-policies)
## Algoritmos criptográficos
Para chaves de host, oferecemos suporte aos seguintes algoritmos:
+ `rsa-sha2-256`
+ `rsa-sha2-512`
+ `ecdsa-sha2-nistp256`
+ `ecdsa-sha2-nistp384`
+ `ecdsa-sha2-nistp521`
+ `ssh-ed25519`
Além disso, as seguintes políticas de segurança permitem`ssh-rsa`:
+ TransferSecurityPolicy-2018-11
+ TransferSecurityPolicy-2020-06
+ TransferSecurityPolicy-FIPS-2020-06
+ TransferSecurityPolicy-FIPS-2023-05
+ TransferSecurityPolicy-FIPS-2024-01
+ TransferSecurityPolicy-PQ-SSH-FIPS-Experimental-2023-04
**nota**
É importante entender a distinção entre o tipo de chave RSA, que é sempre, `ssh-rsa` e o algoritmo de chave de host RSA, que pode ser qualquer um dos algoritmos compatíveis.
Veja a seguir uma lista dos algoritmos criptográficos compatíveis com cada política de segurança.
**nota**
Na tabela e nas políticas a seguir, observe o seguinte uso dos tipos de algoritmo.
Os servidores SFTP usam apenas algoritmos nas **SshMacs**seções **SshCiphers**SshKexs****, e.
Os servidores FTPS usam apenas algoritmos na **TlsCiphers**seção.
Os servidores FTP, como não usam criptografia, não usam nenhum desses algoritmos.
AS2 os servidores usam apenas algoritmos nas **HashAlgorithms**seções **ContentEncryptionCiphers**e. Essas seções definem algoritmos usados para criptografar e assinar o conteúdo do arquivo.
As políticas de segurança FIPS-2024-05 e FIPS-2024-01 são idênticas, exceto que o FIPS-2024-05 não suporta o algoritmo. `ssh-rsa`
A Transfer Family introduziu novas políticas restritas que são muito paralelas às políticas existentes:
As políticas de segurança TransferSecurityPolicy -Restricted-2018-11 e TransferSecurityPolicy -2018-11 são idênticas, exceto que a política restrita não suporta a cifra. `chacha20-poly1305@openssh.com`
As políticas de segurança TransferSecurityPolicy -Restricted-2020-06 e TransferSecurityPolicy -2020-06 são idênticas, exceto que a política restrita não suporta a cifra. `chacha20-poly1305@openssh.com`
\$1 Na tabela a seguir, a `chacha20-poly1305@openssh.com` cifra está incluída somente na política não restrita,
| Política de segurança | 2024-01 | SshAuditCompliant-2025-02 | 2023-05 | 2022-03 | **2020-06** **2020-06 restrito** | **FIPS-2024-05** **FIPS-2024-01** | FIPS-2023-05 | FIPS-2020-06 | **2018-11** **2018-11 restrito** | TransferSecurityPolicy- AS2 Restrito - 2025-07 |
| --- |--- |--- |--- |--- |--- |--- |--- |--- |--- |--- |
| **SshCiphers** |
| --- |
| aes128-ctr | ♦ | ♦ | | | ♦ | ♦ | | ♦ | ♦ | ♦ |
| aes128-gcm@openssh.com | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| aes192-ctr | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| aes256-ctr | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| aes256-gcm@openssh.com | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| chacha20-poly1305@openssh.com | | | | | ♦\$1 | | | | ♦\$1 | |
| **SshKexs** |
| --- |
| mlkem768x25519-sha256 | | | | | | | | | | ♦ |
| mlkem768nistp256-sha256 | | | | | | | | | | ♦ |
| mlkem1024nistp384-sha384 | | | | | | | | | | ♦ |
| curve25519-sha256 | ♦ | ♦ | ♦ | ♦ | | | | | ♦ | ♦ |
| curve25519-sha256@libssh.org | ♦ | ♦ | ♦ | ♦ | | | | | ♦ | ♦ |
| diffie-hellman-group14-sha1 | | | | | | | | | ♦ | |
| diffie-hellman-group14-sha256 | | | | | ♦ | | | ♦ | ♦ | |
| diffie-hellman-group16-sha512 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| diffie-hellman-group18-sha512 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| diffie-hellman-group-exchange-sha256 | ♦ | ♦ | ♦ | ♦ | ♦ | | ♦ | ♦ | ♦ | ♦ |
| ecdh-sha2-nistp256 | ♦ | | | | ♦ | ♦ | | ♦ | ♦ | ♦ |
| ecdh-sha2-nistp384 | ♦ | | | | ♦ | ♦ | | ♦ | ♦ | ♦ |
| ecdh-sha2-nistp521 | ♦ | | | | ♦ | ♦ | | ♦ | ♦ | ♦ |
| **SshMacs** |
| --- |
| hmac-sha1 | | | | | | | | | ♦ | |
| hmac-sha1-etm@openssh.com | | | | | | | | | ♦ | |
| hmac-sha2-256 | | | | ♦ | ♦ | | | ♦ | ♦ | |
| hmac-sha2-256-etm@openssh.com | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| hmac-sha2-512 | | | | ♦ | ♦ | | | ♦ | ♦ | |
| hmac-sha2-512-etm@openssh.com | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| umac-128-etm@openssh.com | | | | | ♦ | | | | ♦ | |
| umac-128-etm@openssh.com | | | | | ♦ | | | | ♦ | |
| umac-64-etm@openssh.com | | | | | | | | | ♦ | |
| umac-64@openssh.com | | | | | | | | | ♦ | |
| **ContentEncryptionCiphers** |
| --- |
| aes256-cbc | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| aes192-cbc | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| aes128-cbc | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| 3des-cbc | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | |
| **HashAlgorithms** |
| --- |
| sha256 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| sha384 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| sha512 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| sha1 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | |
| **TlsCiphers** |
| --- |
| TLS\$1ECDHE\$1ECDSA\$1COM\$1AES\$1128\$1CBC\$1 SHA256 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1ECDSA\$1COM\$1AES\$1128\$1GCM\$1 SHA256 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1ECDSA\$1COM\$1AES\$1256\$1CBC\$1 SHA384 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1ECDSA\$1COM\$1AES\$1256\$1GCM\$1 SHA384 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1COM\$1AES\$1128\$1CBC\$1 SHA256 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1COM\$1AES\$1128\$1GCM\$1 SHA256 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1COM\$1AES\$1256\$1CBC\$1 SHA384 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1COM\$1AES\$1256\$1GCM\$1 SHA384 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1RSA\$1COM\$1AES\$1128\$1CBC\$1 SHA256 | | | | | | | | | ♦ | |
| TLS\$1RSA\$1COM\$1AES\$1256\$1CBC\$1 SHA256 | | | | | | | | | ♦ | |
## TransferSecurityPolicy-2024-01
O seguinte mostra a política de TransferSecurityPolicy segurança -2024-01.
```
{
"SecurityPolicy": {
"Fips": false,
"SecurityPolicyName": "TransferSecurityPolicy-2024-01",
"SshCiphers": [
"aes128-gcm@openssh.com",
"aes256-gcm@openssh.com",
"aes128-ctr",
"aes256-ctr",
"aes192-ctr"
],
"SshKexs": [
"ecdh-sha2-nistp256",
"ecdh-sha2-nistp384",
"ecdh-sha2-nistp521",
"curve25519-sha256",
"curve25519-sha256@libssh.org",
"diffie-hellman-group18-sha512",
"diffie-hellman-group16-sha512",
"diffie-hellman-group-exchange-sha256"
],
"SshMacs": [
"hmac-sha2-256-etm@openssh.com",
"hmac-sha2-512-etm@openssh.com"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc",
"3des-cbc"
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512",
"sha1"
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
]
}
}
```
## TransferSecurityPolicy- SshAuditCompliant -2025-02
O seguinte mostra a política de segurança TransferSecurityPolicy - SshAuditCompliant -2025-02.
**nota**
Essa política de segurança foi projetada com base nas recomendações fornecidas pela `ssh-audit` ferramenta e é 100% compatível com essa ferramenta.
```
{
"SecurityPolicy": {
"Fips": false,
"Protocols": [
"SFTP",
"FTPS"
],
"SecurityPolicyName": "TransferSecurityPolicy-SshAuditCompliant-2025-02",
"SshCiphers": [
"aes128-gcm@openssh.com",
"aes256-gcm@openssh.com",
"aes128-ctr",
"aes256-ctr",
"aes192-ctr"
],
"SshKexs": [
"curve25519-sha256",
"curve25519-sha256@libssh.org",
"diffie-hellman-group18-sha512",
"diffie-hellman-group16-sha512",
"diffie-hellman-group-exchange-sha256"
],
"SshMacs": [
"hmac-sha2-256-etm@openssh.com",
"hmac-sha2-512-etm@openssh.com"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc",
"3des-cbc"
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512",
"sha1"
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
],
"Type": "SERVER"
}
}
```
## TransferSecurityPolicy-2023-05
O seguinte mostra a política de segurança TransferSecurityPolicy -2023-05.
```
{
"SecurityPolicy": {
"Fips": false,
"SecurityPolicyName": "TransferSecurityPolicy-2023-05",
"SshCiphers": [
"aes256-gcm@openssh.com",
"aes128-gcm@openssh.com",
"aes256-ctr",
"aes192-ctr"
],
"SshKexs": [
"curve25519-sha256",
"curve25519-sha256@libssh.org",
"diffie-hellman-group16-sha512",
"diffie-hellman-group18-sha512",
"diffie-hellman-group-exchange-sha256"
],
"SshMacs": [
"hmac-sha2-512-etm@openssh.com",
"hmac-sha2-256-etm@openssh.com"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc",
"3des-cbc"
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512",
"sha1"
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
]
}
}
```
## TransferSecurityPolicy-2022-03
O seguinte mostra a política de TransferSecurityPolicy segurança -2022-03.
```
{
"SecurityPolicy": {
"Fips": false,
"SecurityPolicyName": "TransferSecurityPolicy-2022-03",
"SshCiphers": [
"aes256-gcm@openssh.com",
"aes128-gcm@openssh.com",
"aes256-ctr",
"aes192-ctr"
],
"SshKexs": [
"curve25519-sha256",
"curve25519-sha256@libssh.org",
"diffie-hellman-group16-sha512",
"diffie-hellman-group18-sha512",
"diffie-hellman-group-exchange-sha256"
],
"SshMacs": [
"hmac-sha2-512-etm@openssh.com",
"hmac-sha2-256-etm@openssh.com",
"hmac-sha2-512",
"hmac-sha2-256"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc"
"3des-cbc",
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512"
"sha1"
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
]
}
}
```
## TransferSecurityPolicy-2020-06 e -Restrito -2020-06 TransferSecurityPolicy
O seguinte mostra a política de TransferSecurityPolicy segurança -2020-06.
**nota**
As políticas de segurança TransferSecurityPolicy -Restricted-2020-06 e TransferSecurityPolicy -2020-06 são idênticas, exceto que a política restrita não suporta a cifra. `chacha20-poly1305@openssh.com`
```
{
"SecurityPolicy": {
"Fips": false,
"SecurityPolicyName": "TransferSecurityPolicy-2020-06",
"SshCiphers": [
"chacha20-poly1305@openssh.com", //Not included in TransferSecurityPolicy-Restricted-2020-06
"aes128-ctr",
"aes192-ctr",
"aes256-ctr",
"aes128-gcm@openssh.com",
"aes256-gcm@openssh.com"
],
"SshKexs": [
"ecdh-sha2-nistp256",
"ecdh-sha2-nistp384",
"ecdh-sha2-nistp521",
"diffie-hellman-group-exchange-sha256",
"diffie-hellman-group16-sha512",
"diffie-hellman-group18-sha512",
"diffie-hellman-group14-sha256"
],
"SshMacs": [
"umac-128-etm@openssh.com",
"hmac-sha2-256-etm@openssh.com",
"hmac-sha2-512-etm@openssh.com",
"umac-128@openssh.com",
"hmac-sha2-256",
"hmac-sha2-512"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc"
"3des-cbc",
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512"
"sha1"
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
]
}
}
```
## TransferSecurityPolicy-2018-11 e -Restrito -2018-11 TransferSecurityPolicy
O seguinte mostra a política TransferSecurityPolicy de segurança -2018-11.
**nota**
As políticas de segurança TransferSecurityPolicy -Restricted-2018-11 e TransferSecurityPolicy -2018-11 são idênticas, exceto que a política restrita não suporta a cifra. `chacha20-poly1305@openssh.com`
```
{
"SecurityPolicy": {
"Fips": false,
"SecurityPolicyName": "TransferSecurityPolicy-2018-11",
"SshCiphers": [
"chacha20-poly1305@openssh.com", //Not included in TransferSecurityPolicy-Restricted-2018-11
"aes128-ctr",
"aes192-ctr",
"aes256-ctr",
"aes128-gcm@openssh.com",
"aes256-gcm@openssh.com"
],
"SshKexs": [
"curve25519-sha256",
"curve25519-sha256@libssh.org",
"ecdh-sha2-nistp256",
"ecdh-sha2-nistp384",
"ecdh-sha2-nistp521",
"diffie-hellman-group-exchange-sha256",
"diffie-hellman-group16-sha512",
"diffie-hellman-group18-sha512",
"diffie-hellman-group14-sha256",
"diffie-hellman-group14-sha1"
],
"SshMacs": [
"umac-64-etm@openssh.com",
"umac-128-etm@openssh.com",
"hmac-sha2-256-etm@openssh.com",
"hmac-sha2-512-etm@openssh.com",
"hmac-sha1-etm@openssh.com",
"umac-64@openssh.com",
"umac-128@openssh.com",
"hmac-sha2-256",
"hmac-sha2-512",
"hmac-sha1"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc"
"3des-cbc",
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512",
"sha1"
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384",
"TLS_RSA_WITH_AES_128_CBC_SHA256",
"TLS_RSA_WITH_AES_256_CBC_SHA256"
]
}
}
```
## TransferSecurityPolicy-FIPS-2024-01/ -FIPS-2024-05 TransferSecurityPolicy
Veja a seguir as políticas de segurança TransferSecurityPolicy -FIPS-2024-01 e -FIPS-2024-05. TransferSecurityPolicy
**nota**
O endpoint do serviço FIPS e as políticas de segurança TransferSecurityPolicy -FIPS-2024-01 e TransferSecurityPolicy -FIPS-2024-05 estão disponíveis somente em algumas regiões. AWS Para obter mais informações, consulte [endpoints e cotas do AWS Transfer Family](https://docs.aws.amazon.com/general/latest/gr/transfer-service.html) na *Referência geral da AWS*.
A única diferença entre essas duas políticas de segurança é que TransferSecurityPolicy -FIPS-2024-01 suporta o `ssh-rsa` algoritmo e -FIPS-2024-05 não. TransferSecurityPolicy
```
{
"SecurityPolicy": {
"Fips": true,
"SecurityPolicyName": "TransferSecurityPolicy-FIPS-2024-01",
"SshCiphers": [
"aes128-gcm@openssh.com",
"aes256-gcm@openssh.com",
"aes128-ctr",
"aes256-ctr",
"aes192-ctr"
],
"SshKexs": [
"ecdh-sha2-nistp256",
"ecdh-sha2-nistp384",
"ecdh-sha2-nistp521",
"diffie-hellman-group18-sha512",
"diffie-hellman-group16-sha512",
"diffie-hellman-group-exchange-sha256"
],
"SshMacs": [
"hmac-sha2-256-etm@openssh.com",
"hmac-sha2-512-etm@openssh.com"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc"
"3des-cbc"
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512"
"sha1"
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
]
}
}
```
## TransferSecurityPolicy-FIPS-2023-05
Os detalhes da certificação FIPS AWS Transfer Family podem ser encontrados em [https://csrc.nist.gov/projects/cryptographic-module-validation-program/validated-modules/search/all](https://csrc.nist.gov/projects/cryptographic-module-validation-program/validated-modules/search/all)
O seguinte mostra a política de segurança TransferSecurityPolicy -FIPS-2023-05.
**nota**
O endpoint do serviço FIPS e a política de segurança TransferSecurityPolicy -FIPS-2023-05 só estão disponíveis em algumas regiões. AWS Para obter mais informações, consulte [endpoints e cotas do AWS Transfer Family](https://docs.aws.amazon.com/general/latest/gr/transfer-service.html) na *Referência geral da AWS*.
```
{
"SecurityPolicy": {
"Fips": true,
"SecurityPolicyName": "TransferSecurityPolicy-FIPS-2023-05",
"SshCiphers": [
"aes256-gcm@openssh.com",
"aes128-gcm@openssh.com",
"aes256-ctr",
"aes192-ctr"
],
"SshKexs": [
"diffie-hellman-group16-sha512",
"diffie-hellman-group18-sha512",
"diffie-hellman-group-exchange-sha256"
],
"SshMacs": [
"hmac-sha2-256-etm@openssh.com",
"hmac-sha2-512-etm@openssh.com"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc"
"3des-cbc"
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512"
"sha1"
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
]
}
}
```
## TransferSecurityPolicy-FIPS-2020-06
Os detalhes da certificação FIPS AWS Transfer Family podem ser encontrados em [https://csrc.nist.gov/projects/cryptographic-module-validation-program/validated-modules/search/all](https://csrc.nist.gov/projects/cryptographic-module-validation-program/validated-modules/search/all)
O seguinte mostra a política de segurança TransferSecurityPolicy -FIPS-2020-06.
**nota**
O endpoint do serviço FIPS e a política de segurança TransferSecurityPolicy -FIPS-2020-06 estão disponíveis somente em algumas regiões. AWS Para obter mais informações, consulte [endpoints e cotas do AWS Transfer Family](https://docs.aws.amazon.com/general/latest/gr/transfer-service.html) na *Referência geral da AWS*.
```
{
"SecurityPolicy": {
"Fips": true,
"SecurityPolicyName": "TransferSecurityPolicy-FIPS-2020-06",
"SshCiphers": [
"aes128-ctr",
"aes192-ctr",
"aes256-ctr",
"aes128-gcm@openssh.com",
"aes256-gcm@openssh.com"
],
"SshKexs": [
"ecdh-sha2-nistp256",
"ecdh-sha2-nistp384",
"ecdh-sha2-nistp521",
"diffie-hellman-group-exchange-sha256",
"diffie-hellman-group16-sha512",
"diffie-hellman-group18-sha512",
"diffie-hellman-group14-sha256"
],
"SshMacs": [
"hmac-sha2-256-etm@openssh.com",
"hmac-sha2-512-etm@openssh.com",
"hmac-sha2-256",
"hmac-sha2-512"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc"
"3des-cbc",
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512"
"sha1",
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
]
}
}
```
## TransferSecurityPolicy- AS2 Restrito - 2025-07
Essa política de segurança foi projetada para transferências de AS2 arquivos que exigem segurança aprimorada, excluindo algoritmos criptográficos antigos. Ele suporta criptografia AES moderna e algoritmos de hash SHA-2, ao mesmo tempo em que remove o suporte para algoritmos mais fracos, como 3DES e SHA-1.
```
{
"SecurityPolicy": {
"Fips": false,
"SecurityPolicyName": "TransferSecurityPolicy-AS2Restricted-2025-07",
"SshCiphers": [
"aes256-gcm@openssh.com",
"aes128-gcm@openssh.com",
"aes128-ctr",
"aes256-ctr",
"aes192-ctr"
],
"SshKexs": [
"mlkem768x25519-sha256",
"mlkem768nistp256-sha256",
"mlkem1024nistp384-sha384",
"ecdh-sha2-nistp256",
"ecdh-sha2-nistp384",
"ecdh-sha2-nistp521",
"curve25519-sha256",
"curve25519-sha256@libssh.org",
"diffie-hellman-group16-sha512",
"diffie-hellman-group18-sha512",
"diffie-hellman-group-exchange-sha256"
],
"SshMacs": [
"hmac-sha2-256-etm@openssh.com",
"hmac-sha2-512-etm@openssh.com"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc"
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512"
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
],
"Type": "SERVER",
"Protocols": [
"AS2"
]
}
}
```
## Políticas de segurança Post Quantum
Esta tabela lista os algoritmos das políticas de segurança pós-quântica do Transfer Family. Essas políticas são descritas em detalhes em [Usando a troca híbrida de chaves pós-quânticas com AWS Transfer Family](post-quantum-security-policies.md).
As listas de políticas seguem a tabela.
**nota**
**As políticas pós-quânticas anteriores (**TransferSecurityPolicy-PQ-SSH-Experimental-2023-04 e -PQ-SSH-FIPS-Experimental-2023-04) estão obsoletas**. TransferSecurityPolicy** Em vez disso, recomendamos que você use as novas políticas.
| Política de segurança | TransferSecurityPolicy-2025-03 | TransferSecurityPolicy-FIPS-2025-03 |
| --- |--- |--- |
| **SSH ciphers** |
| --- |
| aes128-ctr | ♦ | ♦ |
| aes128-gcm@openssh.com | ♦ | ♦ |
| aes192-ctr | ♦ | ♦ |
| aes256-ctr | ♦ | ♦ |
| aes256-gcm@openssh.com | ♦ | ♦ |
| **KEXs** |
| --- |
| mlkem768x25519-sha256 | ♦ | ♦ |
| mlkem768nistp256-sha256 | ♦ | ♦ |
| mlkem1024nistp384-sha384 | ♦ | ♦ |
| diffie-hellman-group14-sha256 | ♦ | ♦ |
| diffie-hellman-group16-sha512 | ♦ | ♦ |
| diffie-hellman-group18-sha512 | ♦ | ♦ |
| ecdh-sha2-nistp384 | ♦ | ♦ |
| ecdh-sha2-nistp521 | ♦ | ♦ |
| ecdh-sha2-nistp256 | ♦ | ♦ |
| diffie-hellman-group-exchange-sha256 | ♦ | ♦ |
| curve25519-sha256@libssh.org | ♦ | |
| curve25519-sha256 | ♦ | |
| **MACs** |
| --- |
| hmac-sha2-256-etm@openssh.com | ♦ | ♦ |
| hmac-sha2-512-etm@openssh.com | ♦ | ♦ |
| **ContentEncryptionCiphers** |
| --- |
| aes256-cbc | ♦ | ♦ |
| aes192-cbc | ♦ | ♦ |
| aes128-cbc | ♦ | ♦ |
| 3des-cbc | ♦ | ♦ |
| **HashAlgorithms** |
| --- |
| sha256 | ♦ | ♦ |
| sha384 | ♦ | ♦ |
| sha512 | ♦ | ♦ |
| sha1 | ♦ | ♦ |
| **TLS ciphers** |
| --- |
| TLS\$1ECDHE\$1ECDSA\$1COM\$1AES\$1128\$1CBC\$1 SHA256 | ♦ | ♦ |
| TLS\$1ECDHE\$1ECDSA\$1COM\$1AES\$1128\$1GCM\$1 SHA256 | ♦ | ♦ |
| TLS\$1ECDHE\$1ECDSA\$1COM\$1AES\$1256\$1CBC\$1 SHA384 | ♦ | ♦ |
| TLS\$1ECDHE\$1ECDSA\$1COM\$1AES\$1256\$1GCM\$1 SHA384 | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1COM\$1AES\$1128\$1CBC\$1 SHA256 | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1COM\$1AES\$1128\$1GCM\$1 SHA256 | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1COM\$1AES\$1256\$1CBC\$1 SHA384 | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1COM\$1AES\$1256\$1GCM\$1 SHA384 | ♦ | ♦ |
### TransferSecurityPolicy-2025-03
O seguinte mostra a política de segurança TransferSecurityPolicy -2025-03.
```
{
"SecurityPolicy": {
"Fips": false,
"SecurityPolicyName": "TransferSecurityPolicy-2025-03",
"SshCiphers": [
"aes256-gcm@openssh.com",
"aes128-gcm@openssh.com",
"aes128-ctr",
"aes256-ctr",
"aes192-ctr"
],
"SshKexs": [
"mlkem768x25519-sha256",
"mlkem768nistp256-sha256",
"mlkem1024nistp384-sha384",
"ecdh-sha2-nistp256",
"ecdh-sha2-nistp384",
"ecdh-sha2-nistp521",
"curve25519-sha256",
"curve25519-sha256@libssh.org",
"diffie-hellman-group16-sha512",
"diffie-hellman-group18-sha512",
"diffie-hellman-group-exchange-sha256"
],
"SshMacs": [
"hmac-sha2-256-etm@openssh.com",
"hmac-sha2-512-etm@openssh.com"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc"
"3des-cbc"
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512"
"sha1"
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
],
"Type": "SERVER",
"Protocols": [
"SFTP",
"FTPS"
]
}
}
```
### TransferSecurityPolicy-FIPS-2025-03
O seguinte mostra a política de segurança TransferSecurityPolicy -FIPS-2025-03.
```
{
"SecurityPolicy": {
"Fips": true,
"SecurityPolicyName": "TransferSecurityPolicy-FIPS-2025-03",
"SshCiphers": [
"aes256-gcm@openssh.com",
"aes128-gcm@openssh.com",
"aes256-ctr",
"aes192-ctr",
"aes128-ctr"
],
"SshKexs": [
"mlkem768x25519-sha256",
"mlkem768nistp256-sha256",
"mlkem1024nistp384-sha384",
"ecdh-sha2-nistp256",
"ecdh-sha2-nistp384",
"ecdh-sha2-nistp521",
"diffie-hellman-group-exchange-sha256",
"diffie-hellman-group16-sha512",
"diffie-hellman-group18-sha512"
],
"SshMacs": [
"hmac-sha2-512-etm@openssh.com",
"hmac-sha2-256-etm@openssh.com"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc"
"3des-cbc"
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512"
"sha1"
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
],
"Type": "SERVER",
"Protocols": [
"SFTP",
"FTPS"
]
}
}
```
### TransferSecurityPolicy- AS2 Restrito - 2025-07
O seguinte mostra a política de segurança TransferSecurityPolicy - AS2 Restricted-2025-07.
**nota**
Essa política de segurança é idêntica à TransferSecurityPolicy -2025-03, exceto que ela não suporta 3DES (in ContentEncryptionCiphers) e não suporta (in). SHA1 HashAlgorithms Inclui todos os algoritmos de 2025-03, incluindo algoritmos criptográficos pós-quânticos (mlkem\$1). KEXs
```
{
"SecurityPolicy": {
"Fips": false,
"SecurityPolicyName": "TransferSecurityPolicy-AS2Restricted-2025-07",
"SshCiphers": [
"aes256-gcm@openssh.com",
"aes128-gcm@openssh.com",
"aes128-ctr",
"aes256-ctr",
"aes192-ctr"
],
"SshKexs": [
"mlkem768x25519-sha256",
"mlkem768nistp256-sha256",
"mlkem1024nistp384-sha384",
"ecdh-sha2-nistp256",
"ecdh-sha2-nistp384",
"ecdh-sha2-nistp521",
"curve25519-sha256",
"curve25519-sha256@libssh.org",
"diffie-hellman-group16-sha512",
"diffie-hellman-group18-sha512",
"diffie-hellman-group-exchange-sha256"
],
"SshMacs": [
"hmac-sha2-256-etm@openssh.com",
"hmac-sha2-512-etm@openssh.com"
],
"ContentEncryptionCiphers": [
"aes256-cbc",
"aes192-cbc",
"aes128-cbc"
],
"HashAlgorithms": [
"sha256",
"sha384",
"sha512"
],
"TlsCiphers": [
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
],
"Type": "SERVER",
"Protocols": [
"SFTP",
"FTPS"
]
}
}
```
# Políticas de segurança para conectores AWS Transfer Family SFTP
As políticas de segurança do conector SFTP AWS Transfer Family permitem que você limite o conjunto de algoritmos criptográficos (códigos de autenticação de mensagens (MACs), trocas de chaves (KEXs) e pacotes de criptografia) associados ao seu conector SFTP. A seguir está uma lista dos algoritmos criptográficos suportados para cada política de segurança do conector SFTP.
**nota**
`TransferSFTPConnectorSecurityPolicy-2024-03`é a política de segurança padrão aplicada aos conectores SFTP.
Você pode alterar a política de segurança do seu conector. Selecione **Connectors** no painel de navegação esquerdo do Transfer Family e selecione seu conector. Em seguida, selecione **Editar** na seção de **configuração do Sftp**. Na seção **Opções de algoritmo criptográfico**, escolha qualquer política de segurança disponível na lista suspensa no campo Política de **segurança**.
## Algoritmos criptográficos
Para chaves de host, os conectores SFTP oferecem suporte a todos os algoritmos compatíveis com os servidores Transfer Family, exceto o ed25519:
+ `rsa-sha2-256`
+ `rsa-sha2-512`
+ `ecdsa-sha2-nistp256`
+ `ecdsa-sha2-nistp384`
+ `ecdsa-sha2-nistp521`
Além disso, oferecemos suporte para chaves de host`ssh-rsa`, mas somente para`TransferSFTPConnectorSecurityPolicy-2023-07`.
Para autenticação, os conectores SFTP oferecem suporte aos seguintes tipos de chave:
+ `ssh-rsa`
+ `ecdsa`
## Detalhes da política de segurança do conector SFTP
A tabela a seguir mostra os algoritmos criptográficos específicos suportados por cada política de segurança do conector SFTP.
| Política de segurança | Transferência SFTPConnector SecurityPolicy - FIPS-2024-10 | Transferência SFTPConnector SecurityPolicy -2024-03 | Transferência SFTPConnector SecurityPolicy -2023-07 |
| --- |--- |--- |--- |
| **Ciphers** |
| --- |
| aes128-ctr | | | ♦ |
| aes128-gcm@openssh.com | ♦ | ♦ | ♦ |
| aes192-ctr | | ♦ | ♦ |
| aes256-ctr | | ♦ | ♦ |
| aes256-gcm@openssh.com | ♦ | ♦ | ♦ |
| **Kexs** |
| --- |
| curve25519-sha256 | | ♦ | ♦ |
| curve25519-sha256@libssh.org | | ♦ | ♦ |
| diffie-hellman-group14-sha1 | | | ♦ |
| diffie-hellman-group16-sha512 | | ♦ | ♦ |
| diffie-hellman-group18-sha512 | | ♦ | ♦ |
| diffie-hellman-group-exchange-sha256 | | ♦ | ♦ |
| ecdh-sha2-nistp256 | ♦ | | |
| ecdh-sha2-nistp384 | ♦ | | |
| ecdh-sha2-nistp521 | ♦ | | |
| **Macs** |
| --- |
| hmac-sha2-512-etm@openssh.com | | ♦ | ♦ |
| hmac-sha2-256-etm@openssh.com | | ♦ | ♦ |
| hmac-sha2-512 | ♦ | ♦ | ♦ |
| hmac-sha2-256 | ♦ | ♦ | ♦ |
| hmac-sha1 | | | ♦ |
| hmac-sha1-96 | | | ♦ |
| **Host Key Algorithms** |
| --- |
| rsa-sha2-256 | ♦ | ♦ | ♦ |
| rsa-sha2-512 | ♦ | ♦ | ♦ |
| ecdsa-sha2-nistp256 | ♦ | ♦ | ♦ |
| ecdsa-sha2-nistp384 | | ♦ | ♦ |
| ecdsa-sha2-nistp521 | | ♦ | ♦ |
| ssh-rsa | | | ♦ |
# Usando a troca híbrida de chaves pós-quânticas com AWS Transfer Family
O Transfer Family suporta uma opção híbrida de estabelecimento de chave pós-quântica para o protocolo Secure Shell (SSH). O estabelecimento de uma chave pós-quântica é necessário porque já é possível registrar o tráfego da rede e salvá-lo para ser descriptografado futuramente por um computador quântico, o que é chamado de ataque. *store-now-harvest-later*
É possível usar essa opção ao se conectar ao Transfer Family para transferências seguras de arquivos para dentro e para fora do armazenamento do Amazon Simple Storage Service (Amazon S3) ou do Amazon Elastic File System (Amazon EFS). O estabelecimento de chaves híbridas pós-quânticas em SSH introduz mecanismos de estabelecimento de chaves pós-quânticas, que ele usa em conjunto com algoritmos clássicos de troca de chaves. As chaves SSH criadas com pacotes de criptografia clássicos estão protegidas contra ataques de força bruta com a tecnologia atual. No entanto, não se espera que a criptografia clássica permaneça segura após o surgimento da computação quântica em grande escala no futuro.
Se sua organização depende da confidencialidade de longo prazo de dados passados por uma conexão Transfer Family, você deverá considerar um plano para migrar para criptografia pós-quântica antes que computadores quânticos de grande escala sejam disponibilizados para uso.
Para proteger os dados criptografados hoje contra possíveis ataques futuros, AWS está participando com a comunidade criptográfica no desenvolvimento de algoritmos quânticos resistentes ou pós-quânticos. Implementamos pacotes de criptografia de troca de chaves pós-quânticas híbridas no Transfer Family que combinam elementos clássicos e pós-quânticos.
Esses pacotes de criptografia híbrida estão disponíveis para uso em suas workloads de produção na maioria das Regiões AWS . No entanto, como as características de desempenho e os requisitos de largura de banda dos pacotes de criptografia híbrida são diferentes dos mecanismos clássicos de troca de chaves, recomendamos testá-los em suas conexões do Transfer Family.
Saiba mais sobre criptografia pós-quântica na postagem do blog de segurança sobre [criptografia pós-quântica](https://aws.amazon.com/security/post-quantum-cryptography/).
**Contents**
+ [Sobre a troca de chaves híbrida pós-quântica híbrida no SSH](#pq-about-key-exchange)
+ [Como funciona o estabelecimento de chaves híbrida pós-quântica no Transfer Family](#pqtls-details)
+ [Por que ML-KEM?](#why-mlkem)
+ [Troca de chaves SSH híbrida pós-quântica e requisitos criptográficos (FIPS 140)](#pq-alignment)
+ [Testando a troca de chaves híbrida pós-quântica no Transfer Family](#pq-policy-testing)
+ [Habilite a troca de chaves híbrida pós-quântica em seu endpoint SFTP](#pq-enable-policy)
+ [Configure um cliente SFTP que ofereça suporte à troca de chaves híbrida pós-quântica](#pq-client-openssh)
+ [Confirme a troca de chaves híbrida pós-quântica no SFTP](#pq-verify-exchange)
## Sobre a troca de chaves híbrida pós-quântica híbrida no SSH
O Transfer Family suporta conjuntos de cifras de troca de chaves híbridas pós-quânticas, que usam o algoritmo clássico de troca de chaves [Elliptic Curve Diffie-Hellman](https://csrc.nist.gov/publications/detail/sp/800-56a/rev-3/final) (ECDH) e o ML-KEM. O ML-KEM é um algoritmo pós-quântico de criptografia de chave pública e estabelecimento de chaves que o [Instituto Nacional de Padrões e Tecnologia (NIST)](https://csrc.nist.gov/projects/post-quantum-cryptography) designou como seu primeiro algoritmo padrão de acordo de chave pós-quântico.
O cliente e o servidor ainda fazem uma troca de chaves ECDH. Além disso, o servidor encapsula um segredo compartilhado pós-quântico na chave pública KEM pós-quântica do cliente, que é anunciada na mensagem de troca de chaves SSH do cliente. Essa estratégia combina a alta garantia de uma troca de chaves clássica com a segurança das trocas de chaves pós-quântica propostas, para ajudar a garantir que os apertos de mão sejam protegidos, desde que o ECDH ou o segredo compartilhado pós-quântico não possam ser quebrados.
## Como funciona o estabelecimento de chaves híbrida pós-quântica no Transfer Family
AWS anunciou recentemente o suporte para troca de chaves pós-quânticas em transferências de arquivos SFTP em. AWS Transfer Family O Transfer Family dimensiona com segurança as transferências de business-to-business arquivos para serviços AWS de armazenamento usando SFTP e outros protocolos. O SFTP é uma versão mais segura do Protocolo de Transferência de Arquivos (FTP) que é executado por SSH. O suporte a troca de chaves pós-quânticas do Transfer Family eleva o nível de segurança para transferências de dados por SFTP.
O suporte SFTP de troca de chaves híbrida pós-quântica no Transfer Family inclui a combinação dos algoritmos pós-quânticos ML-KEM-768 e ML-KEM-1024, com ECDH sobre curvas P256, P384 ou Curve25519. Os seguintes métodos de troca de chaves SSH correspondentes são especificados no rascunho de troca de [chaves SSH híbrida pós-quântica](https://datatracker.ietf.org/doc/draft-kampanakis-curdle-ssh-pq-ke/).
+ `mlkem768nistp256-sha256`
+ `mlkem1024nistp384-sha384`
+ `mlkem768x25519-sha256`
### Por que ML-KEM?
AWS está comprometida em oferecer suporte a algoritmos padronizados e interoperáveis. [O ML-KEM é o único algoritmo de troca de chaves pós-quântica padronizado e aprovado pelo projeto de criptografia pós-quântica do NIST.](https://csrc.nist.gov/projects/post-quantum-cryptography) Os órgãos de padronização já estão integrando o ML-KEM aos protocolos. AWS já suporta ML-KEM em TLS em alguns endpoints de API. AWS
Como parte desse compromisso, AWS apresentou um rascunho de proposta ao IETF para criptografia pós-quântica que combina ML-KEM com curvas aprovadas pelo NIST, como P256 para SSH. Para ajudar a melhorar a segurança de nossos clientes, a AWS implementação da troca de chaves pós-quânticas em SFTP e SSH segue esse rascunho. Planejamos oferecer suporte a futuras atualizações até que nossa proposta seja adotada pelo IETF e se torne um padrão.
Os novos métodos de troca de chaves (listados na seção[Como funciona o estabelecimento de chaves híbrida pós-quântica no Transfer Family](#pqtls-details)) podem mudar à medida que o rascunho evolui em direção à padronização.
**nota**
Atualmente, o suporte a algoritmos pós-quânticos está disponível para troca de chaves híbridas pós-quânticas em TLS para AWS KMS (consulte [Uso de TLS híbrido pós-quântico com AWS KMS) e](https://docs.aws.amazon.com/kms/latest/developerguide/pqtls.html) endpoints de API.AWS Certificate Manager AWS Secrets Manager
### Troca de chaves SSH híbrida pós-quântica e requisitos criptográficos (FIPS 140)
Para clientes que precisam de conformidade com FIPS, a Transfer Family fornece criptografia aprovada pelo FIPS em SSH usando a biblioteca criptográfica de código aberto com certificação AWS FIPS 140, -LC. AWS Os métodos de troca de chaves híbridas pós-quânticas suportados no TransferSecurityPolicy -FIPS-2025-03 na Transfer Family são aprovados pelo FIPS de [acordo com](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Cr2.pdf) o SP 800-56Cr2 do NIST (seção 2). O Escritório Federal Alemão de Segurança da Informação ([BSI](https://www.bsi.bund.de/EN/Themen/Unternehmen-und-Organisationen/Informationen-und-Empfehlungen/Quantentechnologien-und-Post-Quanten-Kryptografie/quantentechnologien-und-post-quanten-kryptografie_node.html)) e a Agência Nacional de Segurança da Informação da França([ANSSI](https://www.ssi.gouv.fr/en/publication/anssi-views-on-the-post-quantum-cryptography-transition/), Agence nationale de la sécurité des systèmes d'information) também recomendam esses métodos de troca de chaves híbrida pós-quântica.
## Testando a troca de chaves híbrida pós-quântica no Transfer Family
Esta seção descreve as etapas que você segue para testar a troca de chaves híbrida pós-quântica.
1. [Habilite a troca de chaves híbrida pós-quântica em seu endpoint SFTP](#pq-enable-policy).
1. Use um cliente SFTP (como [Configure um cliente SFTP que ofereça suporte à troca de chaves híbrida pós-quântica](#pq-client-openssh)) que ofereça suporte à troca de chaves híbrida pós-quântica seguindo as orientações na especificação preliminar mencionada acima.
1. Transfira um arquivo usando um servidor Transfer Family.
1. [Confirme a troca de chaves híbrida pós-quântica no SFTP](#pq-verify-exchange).
### Habilite a troca de chaves híbrida pós-quântica em seu endpoint SFTP
É possível escolher a política SSH ao criar um novo endpoint de servidor SFTP no Transfer Family ou ao editar as opções do algoritmo criptográfico em um endpoint SFTP existente. O instantâneo a seguir mostra um exemplo de Console de gerenciamento da AWS onde você atualiza a política SSH.
![\[Mostra a política pós-quântica selecionada para as opções do algoritmo criptográfico.\]](http://docs.aws.amazon.com/pt_br/transfer/latest/userguide/images/post-quantum-policy-choose.png)
**Os nomes das políticas SSH que suportam a troca de chaves pós-quânticas são **TransferSecurityPolicy-2025-03 e -FIPS-2025-03**. TransferSecurityPolicy** Para obter mais detalhes sobre as políticas do Transfer Family, consulte [Políticas de segurança para AWS Transfer Family servidores](security-policies.md).
### Configure um cliente SFTP que ofereça suporte à troca de chaves híbrida pós-quântica
Depois de selecionar a política SSH pós-quântica correta em seu endpoint do SFTP Transfer Family, é possível experimentar o SFTP pós-quântico no Transfer Family. Instale o cliente OpenSSH mais recente (como a versão 9.9) em seu sistema local para testar.
**nota**
Certifique-se de que seu cliente suporte um ou mais dos algoritmos ML-KEM listados anteriormente. Você pode visualizar os algoritmos suportados para sua versão do OpenSSH executando este comando:. `ssh -Q kex`
Você pode executar o cliente SFTP de exemplo para se conectar ao seu endpoint SFTP (por exemplo,`s-1111aaaa2222bbbb3.server.transfer.us-west-2.amazonaws.com`) usando os métodos de troca de chaves híbridas pós-quânticas, conforme mostrado no comando a seguir.
```
sftp -v -o \
KexAlgorithms=mlkem768x25519-sha256 \
-i username_private_key_PEM_file \
username@server-id.server.transfer.region-id.amazonaws.com
```
No comando a seguir, substitua os seguintes itens por suas próprias informações:
+ *username\$1private\$1key\$1PEM\$1file*Substitua pelo arquivo codificado em PEM da chave privada do usuário do SFTP
+ *username*Substitua pelo nome de usuário do SFTP
+ *server-id*Substitua pela ID do servidor Transfer Family
+ *region-id*Substitua pela região real em que seu servidor Transfer Family está localizado
### Confirme a troca de chaves híbrida pós-quântica no SFTP
Para confirmar se a troca de chaves híbrida pós-quântica foi usada durante uma conexão SSH do SFTP com o Transfer Family, verifique a saída do cliente. Opcionalmente, é possível usar um programa de captura de pacotes. Se você usa o cliente OpenSSH 9.9, a saída deve ser semelhante à seguinte (omitindo informações irrelevantes para resumir):
```
% sftp -o KexAlgorithms=mlkem768x25519-sha256 -v -o IdentitiesOnly=yes -i username_private_key_PEM_file username@s-1111aaaa2222bbbb3.server.transfer.us-west-2.amazonaws.com
OpenSSH_9.9p2, OpenSSL 3.4.1 11 Feb 2025
debug1: Reading configuration data /Users/username/.ssh/config
debug1: /Users/username/.ssh/config line 146: Applying options for *
debug1: Reading configuration data /Users/username/.ssh/bastions-config
debug1: Reading configuration data /opt/homebrew/etc/ssh/ssh_config
debug1: Connecting to s-1111aaaa2222bbbb3.server.transfer.us-west-2.amazonaws.com [xxx.yyy.zzz.nnn] port 22.
debug1: Connection established.
[...]
debug1: Local version string SSH-2.0-OpenSSH_9.9
debug1: Remote protocol version 2.0, remote software version AWS_SFTP_1.1
debug1: compat_banner: no match: AWS_SFTP_1.1
debug1: Authenticating to s-1111aaaa2222bbbb3.server.transfer.us-west-2.amazonaws.com:22 as 'username'
debug1: load_hostkeys: fopen /Users/username/.ssh/known_hosts2: No such file or directory
[...]
debug1: SSH2_MSG_KEXINIT sent
debug1: SSH2_MSG_KEXINIT received
debug1: kex: algorithm: mlkem768x25519-sha256
debug1: kex: host key algorithm: ssh-ed25519
debug1: kex: server->client cipher: aes128-ctr MAC: hmac-sha2-256-etm@openssh.com compression: none
debug1: kex: client->server cipher: aes128-ctr MAC: hmac-sha2-256-etm@openssh.com compression: none
debug1: expecting SSH2_MSG_KEX_ECDH_REPLY
debug1: SSH2_MSG_KEX_ECDH_REPLY received
debug1: Server host key: ssh-ed25519 SHA256:Ic1Ti0cdDmFdStj06rfU0cmmNccwAha/ASH2unr6zX0
[...]
debug1: rekey out after 4294967296 blocks
debug1: SSH2_MSG_NEWKEYS sent
debug1: expecting SSH2_MSG_NEWKEYS
debug1: SSH2_MSG_NEWKEYS received
debug1: rekey in after 4294967296 blocks
[...]
Authenticated to s-1111aaaa2222bbbb3.server.transfer.us-west-2.amazonaws.com ([xxx.yyy.zzz.nnn]:22) using "publickey".
debug1: channel 0: new session [client-session] (inactive timeout: 0)
[...]
Connected to s-1111aaaa2222bbbb3.server.transfer.us-west-2.amazonaws.com.
sftp>
```
O resultado mostra que a negociação com o cliente ocorreu usando o método `mlkem768x25519-sha256` híbrido pós-quântico e estabeleceu com sucesso uma sessão de SFTP.
# Proteção e criptografia de dados
O modelo de [responsabilidade AWS compartilhada modelo](https://aws.amazon.com/compliance/shared-responsibility-model/) de se aplica à proteção de dados em AWS Transfer Family (Transfer Family). Conforme descrito neste modelo, AWS é responsável por proteger a infraestrutura global que executa toda a AWS nuvem. Você é responsável por manter o controle sobre o conteúdo hospedado nessa infraestrutura. Esse conteúdo inclui as tarefas de configuração e gerenciamento de segurança dos AWS serviços que você usa. Para obter mais informações sobre a privacidade de dados, consulte as [Perguntas frequentes sobre privacidade de dados](https://aws.amazon.com/compliance/data-privacy-faq). Para obter informações sobre a proteção de dados na Europa, consulte a publicação [Modelo de Responsabilidade Compartilhada e GDPR do AWS](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) no *Blog de segurança da AWS *.
Para fins de proteção de dados, recomendamos que você proteja as credenciais da AWS conta e configure contas de usuário individuais com Centro de Identidade do AWS IAM. Dessa maneira, cada usuário receberá apenas as permissões necessárias para cumprir suas obrigações de trabalho. Recomendamos também que você proteja seus dados das seguintes formas:
+ Use uma autenticação multifator (MFA) com cada conta.
+ Use SSL/TLS para se comunicar com AWS os recursos. Oferecemos suporte ao TLS 1.2.
+ Configure a API e o registro de atividades do usuário com AWS CloudTrail.
+ Use soluções AWS de criptografia, juntamente com todos os controles de segurança padrão nos AWS serviços.
+ Use serviços gerenciados de segurança avançada, como o Amazon Macie, que ajuda a localizar e proteger dados pessoais armazenados no Amazon S3.
+ Se você precisar de módulos criptográficos validados pelo FIPS 140-2 ao acessar a AWS por meio de uma interface de linha de comando ou uma API, use um endpoint do FIPS. Para ter mais informações sobre endpoints do FIPS, consulte [Federal Information Processing Standard (FIPS) 140-2](https://aws.amazon.com/compliance/fips/).
É altamente recomendável que você nunca coloque informações de identificação confidenciais, como números de conta dos seus clientes, em campos de formato livre, como um campo **Nome**. Isso inclui quando você trabalha com o Transfer Family ou outros AWS serviços usando o console AWS CLI, a API ou AWS SDKs. Todos os dados de configuração inseridos por você na configuração do serviço Transfer Family ou em configurações de outros serviços poderão ser selecionados para inclusão em logs de diagnóstico. Ao fornecer um URL para um servidor externo, não inclua informações de credenciais no URL para validar a solicitação a esse servidor.
Por outro lado, os dados das operações de upload e download que entram e saem dos servidores do Transfer Family são tratados como totalmente privados e nunca existem fora dos canais criptografados, como uma conexão SFTP ou FTPS. Esses dados só podem ser acessados por pessoas autorizadas.
## Criptografia de dados no Transfer Family
AWS Transfer Family usa as opções de criptografia padrão que você definiu para seu bucket do Amazon S3 para criptografar seus dados. Ao habilitar a criptografia em um bucket, todos os objetos são criptografados quando armazenados no bucket. Os objetos são criptografados usando criptografia do lado do servidor com chaves gerenciadas do Amazon S3 (SSE-S3) ou AWS Key Management Service () chaves gerenciadas (SSE-KMS) do Amazon S3.AWS KMS Para obter mais informações sobre criptografia no lado do servidor, consulte [Proteger dados usando criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html) no *Guia do usuário do Amazon Simple Storage Service*.
As etapas a seguir mostram como criptografar dados em AWS Transfer Family.
**Para permitir a criptografia em AWS Transfer Family**
1. Habilitar a criptografia padrão para o seu bucket do Amazon S3. Para obter mais detalhes, consulte [Criptografia padrão do Amazon S3 para buckets do S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-encryption.html) no *Guia do usuário do Amazon Simple Storage Service*.
1. Atualize a política de função AWS Identity and Access Management (IAM) anexada ao usuário para conceder as permissões necessárias AWS Key Management Service (AWS KMS).
1. Se você estiver usando uma política de sessão para o usuário, a política de sessão deverá conceder as AWS KMS permissões necessárias.
O exemplo a seguir mostra uma política do IAM que concede as permissões mínimas necessárias ao usar AWS Transfer Family com um bucket do Amazon S3 habilitado para AWS KMS criptografia. Inclua essa política de exemplo na política de perfil do IAM do usuário e na política de restrição se estiver usando uma.
```
{
"Sid": "Stmt1544140969635",
"Action": [
"kms:Decrypt",
"kms:Encrypt",
"kms:GenerateDataKey",
"kms:GetPublicKey",
"kms:ListKeyPolicies"
],
"Effect": "Allow",
"Resource": "arn:aws:kms:region:account-id:key/kms-key-id"
}
```
**nota**
A ID de chave do KMS que você especificar nesta política deverá ser a mesma especificada para a criptografia padrão na etapa 1.
A raiz, ou a função do IAM usada pelo usuário, deve ser permitida na política de AWS KMS chaves. Para obter informações sobre a política de AWS KMS chaves, consulte [Usando políticas de chaves no AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) no *Guia do AWS Key Management Service desenvolvedor*.
## AWS Transfer Family criptografia em repouso
Por ser AWS Transfer Family um serviço de transferência de arquivos, ele não gerencia seus dados de armazenamento em repouso. Os serviços e sistemas de armazenamento que AWS Transfer Family oferecem suporte são responsáveis por proteger os dados nesse estado. No entanto, há alguns dados relacionados ao serviço que são AWS Transfer Family gerenciados em repouso.
### O que é criptografado?
Os únicos dados tratados AWS Transfer Family em repouso estão relacionados aos detalhes necessários para operar seus servidores de transferência de arquivos e processar transferências. AWS Transfer Family armazena os seguintes dados com criptografia total em repouso no Amazon DynamoDB:
+ Configurações do servidor (por exemplo, configurações do servidor, configurações do protocolo e detalhes do endpoint).
+ Dados de autenticação do usuário, incluindo chaves públicas SSH e metadados do usuário.
+ Detalhes da execução do fluxo de trabalho e configurações de etapas.
+ Configurações de conectores e credenciais de autenticação para sistemas de terceiros. Essas credenciais são criptografadas usando chaves de criptografia AWS Transfer Family gerenciadas.
#### Gerenciamento de chaves
Você não pode gerenciar as chaves de criptografia AWS Transfer Family usadas para armazenar informações no DynamoDB relacionadas à execução de seus servidores e ao processamento de transferências. Essas informações incluem as configurações do servidor, dados de autenticação do usuário, detalhes do fluxo de trabalho e credenciais do conector.
### O que não é criptografado?
Embora AWS Transfer Family não controle como seus dados de armazenamento são criptografados em repouso, ainda recomendamos configurar seus locais de armazenamento com o mais alto nível de segurança suportado por eles. Por exemplo, você pode criptografar objetos com chaves de criptografia gerenciadas do Amazon S3 (SSE-S3) ou chaves (SSE-KMS) AWS KMS .
Saiba mais sobre como os serviços AWS de armazenamento criptografam dados em repouso:
+ [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html)
+ [Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/encryption-at-rest.html)
# Gerenciando chaves SSH e PGP no Transfer Family
Nesta seção, você encontrará informações sobre chaves SSH, incluindo como gerá-las e como rotacioná-las. Para obter detalhes sobre como usar o Transfer Family with AWS Lambda para gerenciar chaves, consulte a postagem do blog [Habilitando o gerenciamento de chaves por autoatendimento do usuário com AWS Transfer Family e. AWS Lambda](https://aws.amazon.com/blogs/storage/enabling-user-self-service-key-management-with-aws-transfer-family-and-aws-lambda/) Para implantação e gerenciamento automatizados de usuários com várias chaves SSH, consulte[Módulos Transfer Family Terraform](terraform.md).
**nota**
AWS Transfer Family aceita RSA, ECDSA e ED25519 chaves para autenticação SSH.
Esta seção também aborda como gerar e gerenciar chaves de Pretty Good Privacy (PGP).
Para obter uma visão geral abrangente de todos os algoritmos de criptografia e chave compatíveis, incluindo recomendações para diferentes casos de uso, consulte[Visão geral da criptografia e dos principais algoritmos](#encryption-algorithms-overview).
## Visão geral da criptografia e dos principais algoritmos
AWS Transfer Family suporta diferentes tipos de algoritmos para diferentes propósitos. Entender quais algoritmos usar para seu caso de uso específico ajuda a garantir transferências de arquivos seguras e compatíveis.
**Referência rápida do algoritmo**
| Caso de uso | Algoritmo recomendado | Compatível com FIPS | Observações |
| --- | --- | --- | --- |
| Autenticação SSH/SFTP | RSA (rsa-sha2-256/512), ECDSA ou ED25519 | RSA: Sim, EDSA: Sim, Não ED25519 | Compatível com todos os clientes e servidores SSH |
| Geração de chaves PGP | RSA ou ECC (NIST) | Sim | Para decodificação do fluxo de trabalho |
| Criptografia de arquivos PGP | AES-256 | Sim | Determinado pelo software PGP |
## Algoritmos de autenticação SSH
Esses algoritmos são usados para SSH/SFTP autenticação entre clientes e AWS Transfer Family servidores. Escolha uma delas ao gerar pares de chaves SSH para autenticação de usuário ou chaves de host do servidor.
RSA (recomendado)
**Compatível com todos os clientes e servidores SSH e compatível com FIPS.** Use com o hashing SHA-2 para aumentar a segurança:
+ `rsa-sha2-256`- Recomendado para a maioria dos casos de uso
+ `rsa-sha2-512`- Opção de maior segurança
ED25519
**Moderno e eficiente.** Tamanhos de chave menores com forte segurança:
+ `ssh-ed25519`- Rápido e seguro, mas não compatível com FIPS
ECDSA
**Opção de curva elíptica.** Bom equilíbrio entre segurança e desempenho:
+ `ecdsa-sha2-nistp256`- Curva padrão
+ `ecdsa-sha2-nistp384`- Maior curva de segurança
+ `ecdsa-sha2-nistp521`- Maior curva de segurança
**nota**
Oferecemos suporte `ssh-rsa` SHA1 para políticas de segurança mais antigas. Para obter detalhes, consulte [Algoritmos criptográficos](security-policies.md#cryptographic-algorithms).
**Escolhendo o algoritmo SSH certo**
+ **Para a maioria dos usuários:** use RSA com `rsa-sha2-256` ou `rsa-sha2-512`
+ **Para conformidade com FIPS: use algoritmos** RSA ou ECDSA
+ **Para ambientes modernos:** ED25519 oferece excelente segurança e desempenho
## Algoritmos de criptografia e decodificação PGP
O PGP (Pretty Good Privacy) usa dois tipos de algoritmos trabalhando juntos para criptografar e descriptografar arquivos em fluxos de trabalho:
1. **Algoritmos de pares de chaves** - usados para gerar os pares de public/private chaves para criptografia e assinaturas digitais
1. **Algoritmos simétricos** - usados para criptografar os dados reais do arquivo (os algoritmos de par de chaves criptografam a chave simétrica)
### Algoritmos de pares de chaves PGP
Escolha um desses algoritmos ao gerar pares de chaves PGP para a decodificação do fluxo de trabalho:
RSA (recomendado)
**Recomendado para a maioria dos usuários.** Amplamente suportado, bem estabelecido e compatível com FIPS. Oferece um bom equilíbrio entre segurança e compatibilidade.
ECC (criptografia de curva elíptica)
**Mais eficiente do que o RSA** com tamanhos de chave menores, mantendo uma segurança forte:
+ Curvas **NIST - Curvas** padrão amplamente suportadas e compatíveis com FIPS
+ **BrainPool curvas** - Curvas alternativas para requisitos específicos de conformidade
+ **Curve25519** - Curva moderna de alto desempenho que oferece forte segurança com computação eficiente
ElGamal
**Algoritmo legado.** Suportado para compatibilidade com sistemas mais antigos. Use RSA ou ECC para novas implementações.
Para obter instruções detalhadas sobre a geração de chaves PGP, consulte. [Gerar chaves PGP](generate-pgp-keys.md)
### Algoritmos de criptografia simétrica PGP
Esses algoritmos criptografam os dados reais do arquivo. O algoritmo usado depende de como o arquivo PGP foi criado pelo seu software PGP:
**Algoritmos compatíveis com FIPS (recomendados para ambientes regulamentados)**
+ **AES-128, AES-192, AES-256** - Padrão de criptografia avançado (recomendado)
+ **3DES** - Padrão de criptografia de dados tripla (antigo, use AES quando possível)
**Outros algoritmos suportados**
+ IDEA, Blowfish CAST5, DES, CAMÉLIA-128, TwoFish CAMÉLIA-192, CAMÉLIA-256
**nota**
Você não escolhe o algoritmo simétrico diretamente ao usar AWS Transfer Family fluxos de trabalho - ele é determinado pelo software PGP usado para criar o arquivo criptografado. No entanto, você pode configurar seu software PGP para preferir algoritmos compatíveis com FIPS, como o AES-256.
Para obter mais informações sobre algoritmos simétricos compatíveis, consulte[Algoritmos de criptografia simétrica compatíveis](nominal-steps-workflow.md#symmetric-algorithms).
# Gere chaves SSH para usuários gerenciados por serviços
É possível configurar seu servidor para autenticar os usuários usando o método de autenticação gerenciada por serviço, no qual os nomes de usuário e chaves SSH são armazenados dentro do serviço. A chave SSH pública do usuário é carregada no servidor como propriedade do usuário. Essa chave é usada pelo servidor como parte de um processo padrão de autenticação baseado em chaves. Cada usuário pode ter várias chaves públicas SSH registradas com um servidor individual. Para ver os limites do número de chaves que podem ser armazenadas por usuário, consulte [endpoints e cotas do AWS Transfer Family](https://docs.aws.amazon.com//general/latest/gr/transfer-service.html) no *Referência geral da Amazon Web Services*.
Como alternativa ao método de autenticação gerenciada pelo serviço, você pode autenticar usuários usando um provedor de identidade personalizado ou AWS Directory Service for Microsoft Active Directory. Para acessar mais informações, consulte [Trabalhar com provedores de identidade personalizados](custom-idp-intro.md) ou [Usando o AWS Directory Service para o Microsoft Active Directory](directory-services-users.md).
Um servidor só pode autenticar usuários usando um método (serviço gerenciado, serviço de diretório ou provedor de identidade personalizado), e esse método não pode ser alterado após a criação do servidor.
**Topics**
+ [Criação de chaves SSH no macOS, Linux ou Unix](macOS-linux-unix-ssh.md)
+ [Criar chaves SSH no Microsoft Windows](windows-ssh.md)
+ [Convertendo uma SSH2 chave em formato de chave pública SSH](convert-ssh2-public-key.md)
# Criação de chaves SSH no macOS, Linux ou Unix
Nos sistemas operacionais macOS, Linux ou Unix, você usa o comando `ssh-keygen` para criar uma chave pública SSH e uma chave privada SSH, também conhecida como par de chaves.
**nota**
Nos exemplos a seguir, não especificamos uma frase secreta: nesse caso, a ferramenta solicita que você insira sua senha e a repita para verificar. A criação de uma frase secreta oferece melhor proteção para sua chave privada e também pode melhorar a segurança geral do sistema. Você não pode recuperar sua senha: se você a esquecer, deverá criar uma nova chave.
No entanto, se você estiver gerando uma chave de host do servidor, você *deverá* especificar uma senha vazia, especificando a opção `-N ""` no comando (ou pressionando **Enter** duas vezes quando solicitado), pois os servidores Transfer Family não podem solicitar uma senha na inicialização.
**Para criar chaves SSH em um sistema operacional macOS, Linux ou Unix**
1. Nos sistemas operacionais macOS, Linux ou Unix, abra um terminal de comando.
1. AWS Transfer Family aceita chaves formatadas em RSA, ECDSA e ED25519 -. Escolha o comando apropriado com base no tipo de par de chaves que você está gerando.
**Dica**: `key_name` substitua pelo nome real do seu arquivo de key pair SSH.
+ Gerar um par de chaves RSA de 4096 bits:
```
ssh-keygen -t rsa -b 4096 -f key_name
```
+ Gerar um par de chaves ECDSA de 521 bits (o ECDSA tem tamanhos de bits de 256, 384 e 521):
```
ssh-keygen -t ecdsa -b 521 -f key_name
```
+ Para gerar um par de ED25519 chaves:
```
ssh-keygen -t ed25519 -f key_name
```
Confira a seguir um exemplo de saída `ssh-keygen`.
```
ssh-keygen -t rsa -b 4096 -f key_name
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in key_name.
Your public key has been saved in key_name.pub.
The key fingerprint is:
SHA256:8tDDwPmanTFcEzjTwPGETVWOGW1nVz+gtCCE8hL7PrQ bob.amazon.com
The key's randomart image is:
+---[RSA 4096]----+
| . ....E |
| . = ... |
|. . . = ..o |
| . o + oo = |
| + = .S.= * |
| . o o ..B + o |
| .o.+.* . |
| =o*+*. |
| ..*o*+. |
+----[SHA256]-----+
```
**Dica**: Quando você executa o `ssh-keygen` comando conforme mostrado anteriormente, ele cria as chaves pública e privada como arquivos no diretório atual.
Seu par de chaves SSH agora está pronto para uso. Siga as etapas 3 e 4 para armazenar a chave pública SSH para seus usuários gerenciados pelo serviço. Esses usuários usam as chaves quando transferem arquivos nos endpoints do servidor Transfer Family.
1. Navegue até o arquivo `key_name.pub` e abra-o.
1. Copie o texto e cole-o na **chave pública SSH** para o usuário gerenciado pelo serviço.
1. Abra o AWS Transfer Family console em [https://console.aws.amazon.com/transfer/](https://console.aws.amazon.com/transfer/)e selecione **Servidores** no painel de navegação.
1. Na página **Servidores**, selecione a **ID do servidor** que contém o usuário que você deseja atualizar.
1. Selecione o usuário para o qual você está adicionando uma chave pública.
1. No painel **Chaves públicas SSH**, escolha **Adicionar chave pública SSH**.
![\[O AWS Transfer Family console, mostrando os detalhes do usuário para um usuário selecionado.\]](http://docs.aws.amazon.com/pt_br/transfer/latest/userguide/images/edit-user-add-key-01.png)
1. Cole o texto da chave pública que você gerou na caixa de texto da chave pública SSH e escolha **Adicionar chave**.
![\[O AWS Transfer Family console, mostrando a página Adicionar chave para adicionar uma chave pública.\]](http://docs.aws.amazon.com/pt_br/transfer/latest/userguide/images/edit-user-add-key-02.png)
A nova chave está listada no painel de chave pública SSH.
![\[O AWS Transfer Family console, mostrando a chave pública recém-adicionada na seção de chaves públicas SSH.\]](http://docs.aws.amazon.com/pt_br/transfer/latest/userguide/images/edit-user-add-key-03.png)
# Criar chaves SSH no Microsoft Windows
O Windows inclui o OpenSSH como um recurso incorporado, que você pode usar para gerar chaves SSH no mesmo formato do Linux ou macOS. Como alternativa, você pode usar ferramentas de terceiros, como o gerador de chaves (PuTTYgen) do PuTTY.
## Usando o OpenSSH integrado ao Windows
As versões recentes do Windows incluem o OpenSSH por padrão. Você pode usar os mesmos `ssh-keygen` comandos descritos na seção macOS/Linux:
1. Abra o Windows PowerShell ou o prompt de comando.
1. Execute um dos comandos a seguir com base no tipo de chave que você deseja gerar:
+ Gerar um par de chaves RSA de 4096 bits:
```
ssh-keygen -t rsa -b 4096 -f key_name
```
+ Para gerar um par de chaves ECDSA de 521 bits:
```
ssh-keygen -t ecdsa -b 521 -f key_name
```
+ Para gerar um par de ED25519 chaves:
```
ssh-keygen -t ed25519 -f key_name
```
1. Siga as mesmas etapas da macOS/Linux seção para enviar sua chave pública para AWS Transfer Family.
## Usando o Pu TTYgen (ferramenta de terceiros)
Alguns clientes SSH de terceiros para Windows, como o PuTTY, usam formatos de chave diferentes. O PuTTY usa o `PPK` formato para chaves privadas. Se você estiver usando o PuTTY ou ferramentas relacionadas, como o WinSCP, poderá usar o Pu TTYgen para criar chaves nesse formato.
**nota**
Se você apresentar o WinSCP com um arquivo de chave privada que não esteja no formato `.ppk`, esse cliente oferecerá a você a conversão da chave no formato `.ppk`.
Para ver um tutorial sobre como criar chaves SSH usando o PuTTYgen, consulte o site [SSH.com](https://www.ssh.com/ssh/putty/windows/puttygen).
# Convertendo uma SSH2 chave em formato de chave pública SSH
AWS Transfer Family só aceita chaves públicas formatadas em SSH. Se você tiver uma chave SSH2 pública, precisará convertê-la. Uma chave SSH2 pública tem o seguinte formato:
```
---- BEGIN SSH2 PUBLIC KEY ----
Comment: "rsa-key-20160402"
AAAAB3NzaC1yc2EAAAABJQAAAgEAiL0jjDdFqK/kYThqKt7THrjABTPWvXmB3URI
:
:
---- END SSH2 PUBLIC KEY ----
```
Uma chave pública SSH tem o seguinte formato:
```
ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAA...
```
Execute o comando a seguir para converter uma chave pública SSH2 formatada em -em uma chave pública formatada em SSH. *ssh2-key*Substitua pelo nome da sua SSH2 chave e *ssh-key* pelo nome da sua chave SSH.
```
ssh-keygen -i -f ssh2-key.pub > ssh-key.pub
```
# Alterar chaves SSH
Recomendamos as melhores práticas de segurança para mudar as chaves SSH. Geralmente, essa mudança é especificada como parte de uma política de segurança e implementada de forma automática. Dependendo do nível de segurança, para uma comunicação altamente confidencial, um par de chaves SSH pode ser usado somente uma vez. Isso elimina qualquer risco devido a chaves armazenadas. No entanto, é muito mais comum armazenar credenciais SSH por um período e definir um intervalo que não sobrecarregue excessivamente os usuários. É comum um intervalo de tempo de três meses.
**nota**
Para rotação automatizada de chaves SSH usando infraestrutura como código, consulte[Módulos Transfer Family Terraform](terraform.md).
Há dois métodos usados para executar a mudança de chaves SSH:
+ No console, é possível carregar uma nova chave pública SSH e excluir uma chave pública SSH existente.
+ Usando a API, você pode atualizar os usuários existentes usando a [DeleteSshPublicKey](https://docs.aws.amazon.com//transfer/latest/APIReference/API_DeleteSshPublicKey.html)API para excluir a chave pública Secure Shell (SSH) de um usuário e a [ImportSshPublicKey](https://docs.aws.amazon.com/transfer/latest/APIReference/API_ImportSshPublicKey.html)API para adicionar uma nova chave pública Secure Shell (SSH) à conta do usuário.
------
#### [ Console ]
**Para executar uma rotação de teclas no console**
1. Abra o AWS Transfer Family console em [https://console.aws.amazon.com/transfer/](https://console.aws.amazon.com/transfer/).
1. Navegue até a página **Servidores**.
1. Escolha o identificador na coluna **ID do servidor** para ver a página **Configuração do servidor**.
1. Em **Usuários**, marque a caixa de seleção do usuário cuja chave pública SSH você deseja girar, escolha **Ações** e escolha **Adicionar chave** para ver a página **Adicionar chave**.
or
Escolha o nome de usuário para ver a página de **Detalhes do usuário** e, em seguida, escolha **Adicionar chave pública SSH** para ver a página **Adicionar chave**.
1. Insira a nova chave pública SSH e escolha **Adicionar chave**.
**Importante**
O formato da chave pública SSH depende do tipo da chave gerada por você.
Para chaves RSA, o formato é `ssh-rsa string`.
Para ED25519 chaves, o formato é`ssh-ed25519 string`.
Para chaves ECDSA, o tipo de chave começa com `ecdsa-sha2-nistp256`, `ecdsa-sha2-nistp384` ou `ecdsa-sha2-nistp521`, dependendo do tamanho da chave que você gerou. A string inicial é então seguida por `string`, semelhante aos outros tipos de chave.
Você retorna à página **Detalhes do usuário** e a nova chave pública SSH que você acabou de inserir será exibida na seção de **chaves públicas SSH**.
1. Marque a caixa de seleção das chaves antigas que deseja excluir e selecione **Excluir**.
1. Confirme a operação de exclusão inserindo a palavra `delete` e selecione **Excluir**.
------
#### [ API ]
**Para realizar uma rotação de chaves usando a API**
1. Nos sistemas operacionais macOS, Linux ou Unix, abra um terminal de comando.
1. Recupere a chave SSH que você deseja excluir digitando o comando a seguir. Para usar esse comando, substitua `serverID` pela ID do servidor do seu servidor Transfer Family e substitua `username` pelo seu nome de usuário.
```
aws transfer describe-user --server-id='serverID' --user-name='username'
```
O comando retorna detalhes sobre o usuário. Copie o conteúdo do campo `"SshPublicKeyId":`. Você precisará inserir esse valor posteriormente neste procedimento.
```
"SshPublicKeys": [ { "SshPublicKeyBody": "public-key", "SshPublicKeyId": "keyID",
"DateImported": 1621969331.072 } ],
```
1. Em seguida, importe uma nova chave SSH para seu usuário. No prompt, insira o comando a seguir. Para usar esse comando, substitua `serverID` pela ID do servidor do seu servidor Transfer Family, substitua `username` pelo seu nome de usuário e substitua `public-key` pela impressão digital da sua nova chave pública.
```
aws transfer import-ssh-public-key --server-id='serverID' --user-name='username'
--ssh-public-key-body='public-key'
```
``Se o comando for bem-sucedido, nenhuma saída será retornada.
1. Por fim, exclua chave antiga executando o comando a seguir. Para usar esse comando, substitua `serverID` pela ID do servidor do seu servidor Transfer Family, substitua `username` pelo seu nome de usuário e substitua `keyID-from-step-2` pelo valor da ID da chave que você copiou na etapa 2 deste procedimento
```
aws transfer delete-ssh-public-key --server-id='serverID' --user-name='username'
--ssh-public-key-id='keyID-from-step-2'
```
1. (Opcional) Para confirmar que a chave antiga não existe mais, repita a etapa 2.
------
# Gerar chaves PGP
É possível usar a decodificação Pretty Good Privacy (PGP) com os arquivos que o Transfer Family processa com fluxos de trabalho. Para usar a descriptografia em uma etapa do fluxo de trabalho, forneça uma chave PGP. Para obter informações detalhadas sobre algoritmos de chave PGP, incluindo recomendações e conformidade com FIPS, consulte. [Algoritmos de pares de chaves PGP](key-management.md#pgp-key-algorithms)
O blog AWS de armazenamento tem uma postagem que descreve como simplesmente descriptografar arquivos sem escrever nenhum código usando fluxos de trabalho do Transfer Family Managed, [criptografar e descriptografar](https://aws.amazon.com/blogs/storage/encrypt-and-decrypt-files-with-pgp-and-aws-transfer-family/) arquivos com PGP e. AWS Transfer Family
O operador que você usa para gerar suas chaves PGP depende do seu sistema operacional e da versão do software de geração de chaves que você está usando.
Se você estiver usando Linux ou Unix, use seu instalador de pacotes para instalar `gpg`. Dependendo da sua distribuição Linux, um dos comandos a seguir deve funcionar para você.
```
sudo yum install gnupg
```
```
sudo apt-get install gnupg
```
Para Windows ou macOS, é possível baixar o que precisa em [https://gnupg.org/download/](https://gnupg.org/download/).
Depois de instalar o software gerador de chaves PGP, execute o comando `gpg --full-gen-key` ou `gpg --gen-key` para gerar um par de chaves.
**nota**
Se você estiver usando o `GnuPG` versão 2.3.0 ou mais recente, deverá executar `gpg --full-gen-key`. Quando solicitado sobre o tipo de chave a ser criada, escolha RSA ou ECC. Se você escolher **ECC**, poderá escolher NIST entre BrainPool e Curve25519 para a curva elíptica.
**Subcomandos `gpg` úteis**
A seguir estão alguns subcomandos úteis para `gpg`:
+ `gpg --help` — Esse comando lista as opções disponíveis e pode incluir alguns exemplos.
+ `gpg --list-keys`— Esse comando lista os detalhes de todos os pares de chaves que você criou.
+ `gpg --fingerprint`— Esse comando lista os detalhes de todos os seus pares de chaves, incluindo a impressão digital de cada chave.
+ `gpg --export -a user-name` — Esse comando exporta a parte da chave pública para o `user-name` que foi usada quando a chave foi gerada.
# Gerenciar chaves PGP
Para gerenciar suas chaves PGP, use. AWS Secrets Manager
**nota**
Seu nome secreto inclui a ID do servidor Transfer Family. Isso significa que você já deve ter identificado ou criado um servidor *antes* de poder armazenar as informações de sua chave PGP em AWS Secrets Manager.
Se quiser usar uma chave e uma senha para todos os seus usuários, é possível armazenar as informações do bloco da chave PGP sob o nome secreto `aws/transfer/server-id/@pgp-default`, onde `server-id` é a ID do seu servidor Transfer Family. O Transfer Family usa essa chave padrão se não houver uma chave que `user-name` corresponda ao usuário que está executando o fluxo de trabalho.
Você pode criar uma chave para um usuário específico. Nesse caso, o formato do nome secreto é`aws/transfer/server-id/user-name`, onde `user-name` corresponde ao usuário que está executando o fluxo de trabalho para um servidor Transfer Family.
**nota**
É possível armazenar no máximo 3 chaves privadas PGP por servidor Transfer Family por usuário.
**Para configurar chaves PGP para uso com decodificação**
1. Dependendo da versão do GPG que você está usando, execute um dos comandos a seguir para gerar um par de chaves PGP.
+ Se você estiver usando a versão 2.3.0 ou mais recente do **GnuPG**, execute o seguinte comando:
```
gpg --full-gen-key
```
Você pode escolher ou**RSA**, se quiser**ECC**, pode escolher entre uma **NIST** **BrainPool** ou a **Curve25519** curva elíptica. Se você executar `gpg --gen-key` em vez disso, você cria um par de chaves que usa o algoritmo de criptografia ECC Curve 25519.
+ Para versões do **GnuPG** anteriores à 2.3.0, é possível usar o comando a seguir, já que RSA é o tipo de criptografia padrão.
```
gpg --gen-key
```
**Importante**
Durante o processo de geração da chave, você deve fornecer uma senha e um endereço de e-mail. Certifique-se de anotar esses valores. Você deve fornecer a senha ao inserir os detalhes da chave AWS Secrets Manager posteriormente neste procedimento. E você deve fornecer o mesmo endereço de e-mail para exportar a chave privada na próxima etapa.
1. Execute o comando a seguir para exportar a chave privada. Para usar esse comando, substitua `private.pgp` pelo nome do arquivo no qual salvar o bloco de chave privada e `marymajor@example.com` pelo endereço de e-mail que você usou ao gerar o par de chaves.
```
gpg --output private.pgp --armor --export-secret-key marymajor@example.com
```
1. Use AWS Secrets Manager para armazenar sua chave PGP.
1. Faça login no Console de gerenciamento da AWS e abra o AWS Secrets Manager console em [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. No painel de navegação à esquerda, selecione **Segredos**.
1. Na página **Segredos**, escolha **Armazenar um novo segredo**.
1. Na página **Escolher tipo de segredo**, em **Tipo de segredo**, selecione **Outro tipo de segredo**.
1. Na seção **Pares de chave/valor**, escolha a guia **Chave/valor**.
+ **Chave** — Insira **PGPPrivateKey**.
**nota**
Você deve inserir a string **PGPPrivateKey** exatamente: não adicione espaços antes ou entre os caracteres.
+ **valor** – cole o texto da sua chave privada no campo de valor. É possível encontrar o texto da sua chave privada no arquivo (por exemplo, `private.pgp`) que você especificou ao exportar sua chave anteriormente neste procedimento. A chave começa com `-----BEGIN PGP PRIVATE KEY BLOCK-----` e termina com `-----END PGP PRIVATE KEY BLOCK-----`.
**nota**
Certifique-se de que o bloco de texto contenha somente a chave privada e também não contenha a chave pública.
1. Escolha **Adicionar linha** e, na seção **Pares de chave/valor**, escolha a guia **Chave/valor**.
+ **Chave** — Insira **PGPPassphrase**.
**nota**
Você deve inserir a string **PGPPassphrase** exatamente: não adicione espaços antes ou entre os caracteres.
+ **valor** — Insira a frase secreta que você usou ao gerar seu par de chaves PGP.
![\[\]](http://docs.aws.amazon.com/pt_br/transfer/latest/userguide/images/pgp-secrets-01.png)
**nota**
É possível adicionar até três conjuntos de chaves e senhas. Para adicionar um segundo conjunto, adicione duas novas linhas, insira **PGPPrivateKey2** e **PGPPassphrase2** para as chaves e cole em outra chave privada e frase secreta. Para adicionar um terceiro conjunto, os valores-chave devem ser **PGPPrivateKey3** e **PGPPassphrase3**.
1. Escolha **Próximo**.
1. Na página **Configurar segredo**, insira um nome e uma descrição para seu segredo.
+ Se você estiver criando uma chave padrão, ou seja, uma chave que possa ser usada por qualquer usuário do Transfer Family, insira **aws/transfer/*server-id*/@pgp-default**. Substitua `server-id` pela ID do servidor que contém o fluxo de trabalho que tem uma etapa de decriptografia.
+ Se você estiver criando uma chave para ser usada por um usuário específico do Transfer Family, insira **aws/transfer/*server-id*/*user-name***. Substitua `server-id` pela ID do servidor que contém o fluxo de trabalho que tem uma etapa de decriptografia e substitua `user-name` pelo nome do usuário que está executando o fluxo de trabalho. O `user-name` é armazenado no provedor de identidade que o servidor Transfer Family está usando.
1. Escolha **Avançar** e aceite os padrões na página **Configurar rotação**. Em seguida, escolha **Próximo**.
1. Na página **Revisão**, escolha **Armazenar** para criar e armazenar o segredo.
A captura de tela a seguir mostra os detalhes para o usuário **marymajor** de um servidor Transfer Family específico. Este exemplo mostra três chaves e suas frases secretas correspondentes.
![\[\]](http://docs.aws.amazon.com/pt_br/transfer/latest/userguide/images/pgp-secrets-02.png)
# Clientes PGP compatíveis
Os clientes a seguir foram testados com o Transfer Family e podem ser usados para gerar chaves PGP e criptografar arquivos que você pretende decriptografar com um fluxo de trabalho.
+ **Gpg4win \$1 Kleopatra**.
**nota**
Ao selecionar **Assinar/Criptografar arquivos**, certifique-se de limpar a seleção de **Assinar como**: atualmente não oferecemos suporte à assinatura de arquivos criptografados.
![\[\]](http://docs.aws.amazon.com/pt_br/transfer/latest/userguide/images/workflows-step-decrypt-kleopatra.png)
Se você assinar o arquivo criptografado e tentar carregá-lo em um servidor Transfer Family com um fluxo de trabalho de descriptografia, você receberá o seguinte erro:
```
Encrypted file with signed message unsupported
```
+ Versões principais do **GnuPG**: 2.4, 2.3, 2.2, 2.0 e 1.4.
Observe que outros clientes PGP também podem funcionar, mas somente os clientes mencionados aqui foram testados com o Transfer Family.
# Gerenciamento de identidade e acesso para AWS Transfer Family
AWS Identity and Access Management (IAM) ajuda o administrador AWS service (Serviço da AWS) a controlar com segurança o acesso aos AWS recursos. Os administradores do IAM controlam quem pode ser *autenticado* (conectado) e *autorizado* (tem permissões) a usar AWS Transfer Family os recursos. O IAM é um AWS service (Serviço da AWS) que você pode usar sem custo adicional.
**Topics**
+ [Público](#security_iam_audience)
+ [Autenticação com identidades](#security_iam_authentication)
+ [Gerenciar o acesso usando políticas](#security_iam_access-manage)
+ [Como AWS Transfer Family funciona com o IAM](security_iam_service-with-iam.md)
+ [AWS Transfer Family exemplos de políticas baseadas em identidade](security_iam_id-based-policy-examples.md)
+ [AWS Transfer Family exemplos de políticas baseadas em tags](security_iam_tag-based-policy-examples.md)
+ [Solução de problemas AWS Transfer Family de identidade e acesso](security_iam_troubleshoot.md)
+ [Chaves de condição do IAM para governança organizacional](transfer-condition-keys.md)
## Público
A forma como você usa AWS Identity and Access Management (IAM) difere com base na sua função:
+ **Usuário do serviço**: solicite permissões ao seu administrador se você não conseguir acessar os atributos (consulte [Solução de problemas AWS Transfer Family de identidade e acesso](security_iam_troubleshoot.md)).
+ **Administrador do serviço**: determine o acesso do usuário e envie solicitações de permissão (consulte [Como AWS Transfer Family funciona com o IAM](security_iam_service-with-iam.md))
+ **Administrador do IAM**: escreva políticas para gerenciar o acesso (consulte [AWS Transfer Family exemplos de políticas baseadas em identidade](security_iam_id-based-policy-examples.md))
## Autenticação com identidades
A autenticação é a forma como você faz login AWS usando suas credenciais de identidade. Você deve estar autenticado como usuário do IAM ou assumindo uma função do IAM. Usuário raiz da conta da AWS
Você pode fazer login como uma identidade federada usando credenciais de uma fonte de identidade como Centro de Identidade do AWS IAM (IAM Identity Center), autenticação de login único ou credenciais. Google/Facebook Para ter mais informações sobre como fazer login, consulte [Como fazer login em sua Conta da AWS](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) no *Guia do usuário do Início de Sessão da AWS *.
Para acesso programático, AWS fornece um SDK e uma CLI para assinar solicitações criptograficamente. Para ter mais informações, consulte [AWS Signature Version 4 para solicitações de API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) no *Guia do usuário do IAM*.
### Usuário raiz da conta da AWS
Ao criar um Conta da AWS, você começa com uma identidade de login chamada *usuário Conta da AWS raiz* que tem acesso completo a todos Serviços da AWS os recursos. É altamente recomendável não usar o usuário-raiz em tarefas diárias. Consulte as tarefas que exigem credenciais de usuário-raiz em [Tarefas que exigem credenciais de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks) no *Guia do usuário do IAM*.
### Identidade federada
Como prática recomendada, exija que os usuários humanos usem a federação com um provedor de identidade para acessar Serviços da AWS usando credenciais temporárias.
Uma *identidade federada* é um usuário do seu diretório corporativo, provedor de identidade da web ou Directory Service que acessa Serviços da AWS usando credenciais de uma fonte de identidade. As identidades federadas assumem funções que oferecem credenciais temporárias.
Para o gerenciamento de acesso centralizado, recomendamos Centro de Identidade do AWS IAM. Para saber mais, consulte [O que é o IAM Identity Center?](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
### Usuários e grupos do IAM
Um *[usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)* é uma identidade com permissões específicas para uma única pessoa ou aplicação. É recomendável usar credenciais temporárias, em vez de usuários do IAM com credenciais de longo prazo. Para obter mais informações, consulte [Exigir que usuários humanos usem a federação com um provedor de identidade para acessar AWS usando credenciais temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) no *Guia do usuário do IAM*.
Um [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) especifica um conjunto de usuários do IAM e facilita o gerenciamento de permissões para grandes conjuntos de usuários. Para ter mais informações, consulte [Casos de uso de usuários do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html) no *Guia do usuário do IAM*.
### Perfis do IAM
Uma *[perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* é uma identidade com permissões específicas que oferece credenciais temporárias. Você pode assumir uma função [mudando de um usuário para uma função do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html) ou chamando uma operação de AWS API AWS CLI ou. Para saber mais, consulte [Métodos para assumir um perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage-assume.html) no *Manual do usuário do IAM*.
Os perfis do IAM são úteis para acesso de usuário federado, permissões de usuário do IAM temporárias, acesso entre contas, acesso entre serviços e aplicações em execução no Amazon EC2. Consulte mais informações em [Acesso a recursos entre contas no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) no *Guia do usuário do IAM*.
## Gerenciar o acesso usando políticas
Você controla o acesso AWS criando políticas e anexando-as a AWS identidades ou recursos. Uma política define permissões quando associada a uma identidade ou recurso. AWS avalia essas políticas quando um diretor faz uma solicitação. A maioria das políticas é armazenada AWS como documentos JSON. Para ter mais informações sobre documentos de política JSON, consulte [Visão geral das políticas JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json) no *Guia do usuário do IAM*.
Por meio de políticas, os administradores especificam quem tem acesso a que, definindo qual **entidade principal** pode realizar **ações** em quais **recursos** e sob quais **condições**.
Por padrão, usuários e perfis não têm permissões. Um administrador do IAM cria políticas do IAM e as adiciona aos perfis, os quais os usuários podem então assumir. As políticas do IAM definem permissões, independentemente do método usado para realizar a operação.
### Políticas baseadas em identidade
As políticas baseadas em identidade são documentos de políticas de permissão JSON que você anexa a uma identidade (usuário, grupo ou perfil). Essas políticas controlam quais ações as identidades podem realizar, em quais recursos e sob quais condições. Para saber como criar uma política baseada em identidade, consulte [Definir permissões personalizadas do IAM com as políticas gerenciadas pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) no *Guia do Usuário do IAM*.
As políticas baseadas em identidade podem ser políticas *em linha* (incorporadas diretamente em uma única identidade) ou *políticas gerenciadas* (políticas autônomas anexadas a várias identidades). Para saber como escolher entre uma política gerenciada e políticas em linha, consulte [Escolher entre políticas gerenciadas e políticas em linha](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-choosing-managed-or-inline.html) no *Guia do usuário do IAM*.
### Políticas baseadas em recursos
Políticas baseadas em recursos são documentos de políticas JSON que você anexa a um recurso. Entre os exemplos estão *políticas de confiança de perfil* do IAM e *políticas de bucket* do Amazon S3. Em serviços compatíveis com políticas baseadas em recursos, os administradores de serviço podem usá-las para controlar o acesso a um recurso específico. É necessário [especificar uma entidade principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html) em uma política baseada em recursos.
Políticas baseadas em recursos são políticas em linha localizadas nesse serviço. Você não pode usar políticas AWS gerenciadas do IAM em uma política baseada em recursos.
### Listas de controle de acesso (ACLs)
As listas de controle de acesso (ACLs) controlam quais diretores (membros da conta, usuários ou funções) têm permissões para acessar um recurso. ACLs são semelhantes às políticas baseadas em recursos, embora não usem o formato de documento de política JSON.
O Amazon S3 e o AWS WAF Amazon VPC são exemplos de serviços que oferecem suporte. ACLs Para saber mais ACLs, consulte a [visão geral da lista de controle de acesso (ACL)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html) no *Guia do desenvolvedor do Amazon Simple Storage Service*.
### Outros tipos de política
AWS oferece suporte a tipos de políticas adicionais que podem definir o máximo de permissões concedidas por tipos de políticas mais comuns:
+ **Limites de permissões**: definem o número máximo de permissões que uma política baseada em identidade pode conceder a uma entidade do IAM. Para saber mais sobre limites de permissões, consulte [Limites de permissões para identidades do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html) no *Guia do usuário do IAM*.
+ **Políticas de controle de serviço (SCPs)** — Especifique as permissões máximas para uma organização ou unidade organizacional em AWS Organizations. Para saber mais, consulte [Políticas de controle de serviço](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) no *Guia do usuário do AWS Organizations *.
+ **Políticas de controle de recursos (RCPs)** — Defina o máximo de permissões disponíveis para recursos em suas contas. Para obter mais informações, consulte [Políticas de controle de recursos (RCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html) no *Guia AWS Organizations do usuário*.
+ **Políticas de sessão**: políticas avançadas transmitidas como um parâmetro durante a criação de uma sessão temporária para um perfil ou um usuário federado. Para saber mais, consulte [Políticas de sessão](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session) no *Guia do usuário do IAM*.
### Vários tipos de política
Quando vários tipos de política são aplicáveis a uma solicitação, é mais complicado compreender as permissões resultantes. Para saber como AWS determinar se uma solicitação deve ser permitida quando vários tipos de políticas estão envolvidos, consulte [Lógica de avaliação de políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html) no *Guia do usuário do IAM*.
# Como AWS Transfer Family funciona com o IAM
Antes de usar o AWS Identity and Access Management (IAM) para gerenciar o acesso AWS Transfer Family, você deve entender quais recursos do IAM estão disponíveis para uso AWS Transfer Family. Para ter uma visão de alto nível de como AWS Transfer Family e outros AWS serviços funcionam com o IAM, consulte [AWS os serviços que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) no *Guia do usuário do IAM*.
**Topics**
+ [AWS Transfer Family políticas baseadas em identidade](#security_iam_service-with-iam-id-based-policies)
+ [AWS Transfer Family políticas baseadas em recursos](#security_iam_service-with-iam-resource-based-policies)
+ [Autorização baseada em AWS Transfer Family tags](#security_iam_service-with-iam-tags)
+ [AWS Transfer Family Funções do IAM](#security_iam_service-with-iam-roles)
## AWS Transfer Family políticas baseadas em identidade
Com as políticas baseadas em identidade do IAM, é possível especificar ações permitidas ou negadas e recursos, bem como as condições sob as quais as ações são permitidas ou negadas. O AWS Transfer Family oferece suporte a ações, recursos e chaves de condição específicos. Para saber mais sobre todos os elementos usados em uma política JSON, consulte [Referência de elementos de política JSON do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) no *AWS Identity and Access Management Guia do usuário do *.
### Ações
Os administradores podem usar políticas AWS JSON para especificar quem tem acesso ao quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.
O elemento `Action` de uma política JSON descreve as ações que podem ser usadas para permitir ou negar acesso em uma política. Incluem ações em uma política para conceder permissões para executar a operação associada.
As ações políticas AWS Transfer Family usam o seguinte prefixo antes da ação:`transfer:`. Por exemplo, para conceder permissão a alguém para criar uma VPC com a operação da API `CreateServer` do Transfer Family, inclua a ação `transfer:CreateServer` na política da pessoa. As declarações de política devem incluir um elemento `Action` ou AWS Transfer Family . O `NotAction` define seu próprio conjunto de ações que descrevem as tarefas que podem ser executadas com esse serviço.
Para especificar várias ações em uma única declaração, separe-as com vírgulas, conforme a seguir.
```
"Action": [
"transfer:action1",
"transfer:action2"
```
Você também pode especificar várias ações utilizando caracteres curinga (\$1). Por exemplo, para especificar todas as ações que começam com a palavra `Describe`, inclua a ação a seguir:
```
"Action": "transfer:Describe*"
```
Para ver uma lista de AWS Transfer Family ações, consulte [Ações definidas por AWS Transfer Family](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awstransferfamily.html#awstransferfamily-actions-as-permissions) na *Referência de Autorização de Serviço*.
### Recursos
Os administradores podem usar políticas AWS JSON para especificar quem tem acesso ao quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.
O elemento de política JSON `Resource` especifica o objeto ou os objetos aos quais a ação se aplica. Como prática recomendada, especifique um recurso usando seu [nome do recurso da Amazon (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html). Para ações que não oferecem compatibilidade com permissões em nível de recurso, use um curinga (\$1) para indicar que a instrução se aplica a todos os recursos.
```
"Resource": "*"
```
O recurso de servidor Transfer Family tem o ARN a seguir.
```
arn:aws:transfer:${Region}:${Account}:server/${ServerId}
```
Por exemplo, para especificar o servidor do Transfer Family `s-01234567890abcdef` em sua instrução, use o seguinte ARN.
```
"Resource": "arn:aws:transfer:us-east-1:123456789012:server/s-01234567890abcdef"
```
Para obter mais informações sobre o formato de ARNs, consulte [Amazon Resource Names (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) na *Referência de autorização de serviço* ou [IAM ARNs](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-arns) no *Guia do usuário do IAM*.
Para especificar todas as instâncias que pertencem a uma conta específica, use o caractere curinga (\$1).
```
"Resource": "arn:aws:transfer:us-east-1:123456789012:server/*"
```
Algumas AWS Transfer Family ações são executadas em vários recursos, como as usadas nas políticas do IAM. Nesses casos, é necessário utilizar o caractere curinga (\$1).
```
"Resource": "arn:aws:transfer:*:123456789012:server/*"
```
Em alguns casos, você precisa especificar mais de um tipo de recurso, por exemplo, se você criar uma política que permita acesso aos servidores e usuários do Transfer Family. Para especificar vários recursos em uma única instrução, separe-os ARNs com vírgulas.
```
"Resource": [
"resource1",
"resource2"
]
```
Para ver uma lista de AWS Transfer Family recursos, consulte [Tipos de recursos definidos AWS Transfer Family](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awstransferfamily.html#awstransferfamily-resources-for-iam-policies) na *Referência de Autorização de Serviço*.
### Chaves de condição
Os administradores podem usar políticas AWS JSON para especificar quem tem acesso ao quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.
O elemento `Condition` especifica quando as instruções são executadas com base em critérios definidos. É possível criar expressões condicionais que usem [agentes de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), como “igual a” ou “menor que”, para fazer a condição da política corresponder aos valores na solicitação. Para ver todas as chaves de condição AWS globais, consulte as [chaves de contexto de condição AWS global](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no *Guia do usuário do IAM*.
AWS Transfer Family define seu próprio conjunto de chaves de condição e também oferece suporte ao uso de algumas chaves de condição globais. Para ver uma lista de chaves de AWS Transfer Family condição, consulte [Chaves de condição AWS Transfer Family](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awstransferfamily.html#awstransferfamily-policy-keys) na *Referência de autorização de serviço*.
### Exemplos
Para ver exemplos de políticas AWS Transfer Family baseadas em identidade, consulte. [AWS Transfer Family exemplos de políticas baseadas em identidade](security_iam_id-based-policy-examples.md) Para políticas de IAM específicas do VPC endpoint, consulte. [Limitando o acesso ao VPC endpoint para servidores Transfer Family](create-server-in-vpc.md#limit-vpc-endpoint-access)
## AWS Transfer Family políticas baseadas em recursos
Políticas baseadas em recursos são documentos de política JSON que especificam quais ações um diretor específico pode realizar no AWS Transfer Family recurso e sob quais condições. O Amazon S3 oferece suporte a políticas de permissões baseadas em recursos para o Amazon S3. *buckets* As políticas baseadas em recursos permitem conceder permissão de uso a outras contas especificada por recurso. Você também pode usar uma política baseada em recursos para permitir que um AWS serviço acesse seu Amazon S3. *buckets*
Para permitir o acesso entre contas, é possível especificar uma conta inteira ou as entidades do IAM em outra conta como a [entidade principal em uma política baseada em recurso](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html). Adicionar uma entidade principal entre contas à política baseada em recurso é apenas metade da tarefa de estabelecimento da relação de confiança. Quando o principal e o recurso estão em AWS contas diferentes, você também deve conceder permissão à entidade principal para acessar o recurso. Conceda permissão anexando uma política baseada em identidade para a entidade. No entanto, se uma política baseada em recurso conceder acesso a uma entidade principal na mesma conta, nenhuma política baseada em identidade adicional será necessária. Para obter mais informações, consulte [Como os perfis do IAM diferem de políticas baseadas em recursos ](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html)no *Guia do usuário do AWS Identity and Access Management *.
O serviço Amazon S3 oferece suporte a apenas um tipo de política baseada em recursos chamada **bucket*política*, que é anexada a uma. *bucket* Essa política define quais entidades principais (contas, usuários, perfis e usuários federados) podem realizar ações no objeto.
### Exemplos
Para ver exemplos de políticas AWS Transfer Family baseadas em recursos, consulte. [AWS Transfer Family exemplos de políticas baseadas em tags](security_iam_tag-based-policy-examples.md)
## Autorização baseada em AWS Transfer Family tags
Você pode anexar tags a AWS Transfer Family recursos ou passar tags em uma solicitação para AWS Transfer Family. Para controlar o acesso baseado em tags, forneça informações sobre as tags no [elemento de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) de uma política usando as `transfer:ResourceTag/key-name`, `aws:RequestTag/key-name` ou chaves de condição `aws:TagKeys`. Para obter informações sobre como usar tags para controlar o acesso aos AWS Transfer Family recursos, consulte[AWS Transfer Family exemplos de políticas baseadas em tags](security_iam_tag-based-policy-examples.md).
## AWS Transfer Family Funções do IAM
Uma [função do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) é uma entidade dentro da sua AWS conta que tem permissões específicas.
### Usando credenciais temporárias com AWS Transfer Family
É possível usar credenciais temporárias para fazer login com federação, assumir um perfil do IAM ou assumir um perfil entre contas. Você obtém credenciais de segurança temporárias chamando operações de AWS STS API, como [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)ou [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html).
AWS Transfer Family suporta o uso de credenciais temporárias.
# AWS Transfer Family exemplos de políticas baseadas em identidade
Por padrão, os usuários e os perfis do IAM não têm permissão para criar ou modificar recursos do AWS Transfer Family . Eles também não podem realizar tarefas usando a AWS API Console de gerenciamento da AWS AWS CLI, ou. Um administrador do IAM deve criar políticas do IAM que concedam aos usuários e perfis permissão para executarem operações de API específicas nos recursos especificados de que precisam. O administrador deve anexar essas políticas aos usuários ou grupos do IAM que exigem essas permissões.
Para saber como criar uma política baseada em identidade do IAM usando esses exemplos de documentos de política JSON, consulte [Criar políticas na guia JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) no *Guia do usuário do AWS Identity and Access Management *.
**Topics**
+ [Práticas recomendadas de política](#security_iam_service-with-iam-policy-best-practices)
+ [Usando o AWS Transfer Family console](#security_iam_id-based-policy-examples-console)
+ [Permitir que os usuários visualizem suas próprias permissões](#security_iam_id-based-policy-examples-view-own-permissions)
## Práticas recomendadas de política
As políticas baseadas em identidade determinam se alguém pode criar, acessar ou excluir AWS Transfer Family recursos em sua conta. Essas ações podem incorrer em custos para sua Conta da AWS. Ao criar ou editar políticas baseadas em identidade, siga estas diretrizes e recomendações:
+ **Comece com as políticas AWS gerenciadas e avance para as permissões de privilégios mínimos — Para começar a conceder permissões** aos seus usuários e cargas de trabalho, use as *políticas AWS gerenciadas* que concedem permissões para muitos casos de uso comuns. Eles estão disponíveis no seu Conta da AWS. Recomendamos que você reduza ainda mais as permissões definindo políticas gerenciadas pelo AWS cliente que sejam específicas para seus casos de uso. Para saber mais, consulte [Políticas gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) ou [Políticas gerenciadas pela AWS para funções de trabalho](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) no *Guia do usuário do IAM*.
+ **Aplique permissões de privilégio mínimo**: ao definir permissões com as políticas do IAM, conceda apenas as permissões necessárias para executar uma tarefa. Você faz isso definindo as ações que podem ser executadas em recursos específicos sob condições específicas, também conhecidas como *permissões de privilégio mínimo*. Para saber mais sobre como usar o IAM para aplicar permissões, consulte [Políticas e permissões no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) no *Guia do usuário do IAM*.
+ **Use condições nas políticas do IAM para restringir ainda mais o acesso**: é possível adicionar uma condição às políticas para limitar o acesso a ações e recursos. Por exemplo, é possível escrever uma condição de política para especificar que todas as solicitações devem ser enviadas usando SSL. Você também pode usar condições para conceder acesso às ações de serviço se elas forem usadas por meio de uma ação específica AWS service (Serviço da AWS), como CloudFormation. Para saber mais, consulte [Elementos da política JSON do IAM: condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) no *Guia do usuário do IAM*.
+ **Use o IAM Access Analyzer para validar suas políticas do IAM a fim de garantir permissões seguras e funcionais**: o IAM Access Analyzer valida as políticas novas e existentes para que elas sigam a linguagem de política do IAM (JSON) e as práticas recomendadas do IAM. O IAM Access Analyzer oferece mais de cem verificações de política e recomendações práticas para ajudar a criar políticas seguras e funcionais. Para saber mais, consulte [Validação de políticas do IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) no *Guia do Usuário do IAM*.
+ **Exigir autenticação multifator (MFA**) — Se você tiver um cenário que exija usuários do IAM ou um usuário root, ative Conta da AWS a MFA para obter segurança adicional. Para exigir MFA quando as operações de API forem chamadas, adicione condições de MFA às suas políticas. Para saber mais, consulte [Configuração de acesso à API protegido por MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) no *Guia do Usuário do IAM*.
Para saber mais sobre as práticas recomendadas do IAM, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
## Usando o AWS Transfer Family console
Para acessar o AWS Transfer Family console, você deve ter um conjunto mínimo de permissões. Essas permissões devem permitir que você liste e visualize detalhes sobre os AWS Transfer Family recursos em sua AWS conta. Se você criar uma política baseada em identidade que seja mais restritiva que as permissões mínimas necessárias, o console não funcionará como pretendido para entidades (usuários ou perfis do IAM) com essa política. Para obter mais informações, consulte [Adicionar permissões a um usuário](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) no *Guia do usuário do AWS Identity and Access Management *.
Você não precisa permitir permissões mínimas do console para usuários que estão fazendo chamadas somente para a API AWS CLI ou para a AWS API. Em vez disso, permita o acesso somente às ações que correspondem à operação da API que você está tentando executar.
## Permitir que os usuários visualizem suas próprias permissões
Este exemplo mostra como criar uma política que permita que os usuários do IAM visualizem as políticas gerenciadas e em linha anexadas a sua identidade de usuário. Essa política inclui permissões para concluir essa ação no console ou programaticamente usando a API AWS CLI ou AWS .
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ViewOwnUserInfo",
"Effect": "Allow",
"Action": [
"iam:GetUserPolicy",
"iam:ListGroupsForUser",
"iam:ListAttachedUserPolicies",
"iam:ListUserPolicies",
"iam:GetUser"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
},
{
"Sid": "NavigateInConsole",
"Effect": "Allow",
"Action": [
"iam:GetGroupPolicy",
"iam:GetPolicyVersion",
"iam:GetPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListGroupPolicies",
"iam:ListPolicyVersions",
"iam:ListPolicies",
"iam:ListUsers"
],
"Resource": "*"
}
]
}
```
# AWS Transfer Family exemplos de políticas baseadas em tags
Veja a seguir exemplos de como controlar o acesso aos AWS Transfer Family recursos com base em tags.
## Usando tags para controlar o acesso aos AWS Transfer Family recursos
Condições nas políticas do IAM são parte da sintaxe que você usa para especificar permissões para recursos do AWS Transfer Family . Você pode controlar o acesso aos AWS Transfer Family recursos (como usuários, servidores, funções e outras entidades) com base nas tags desses recursos. As tags são pares de chave-valor. Para obter mais informações sobre como marcar recursos, consulte Como [marcar AWS recursos](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) no. *Referência geral da AWS*
Em AWS Transfer Family, os recursos podem ter tags e algumas ações podem incluir tags. Ao criar uma política do IAM, é possível usar chaves de condição de tag para controlar o seguinte:
+ Quais usuários podem realizar ações em um AWS Transfer Family recurso, com base nas tags que o recurso tem.
+ Quais tags podem ser transmitidas na solicitação de uma ação.
+ Se chaves de tags específicas podem ser usadas em uma solicitação.
Ao usar o controle de acesso baseado em tags, é possível aplicar um controle mais preciso do que no nível da API. Você também pode aplicar um controle mais dinâmico do que usando o controle de acesso baseado em recursos. É possível criar políticas do IAM que permitem ou não uma operação baseada em tags fornecidas na solicitação (tags de solicitação). Você também pode criar políticas do IAM baseadas em tags no recurso em que estão sendo operadas (tags de recurso). Em geral, as tags de recursos são para tags que já estão nos recursos, e as tags de solicitação são para quando você adiciona ou remove tags de um recurso.
Para obter a sintaxe e a semântica completas das chaves de condição de tag, consulte [Controlar o acesso a recursos AWS usando tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) no *Guia do usuário do IAM*. Para obter detalhes sobre a especificação de políticas do IAM com o API Gateway, consulte [Controlar o acesso a uma API com permissões do IAM](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) no *Guia do desenvolvedor do API Gateway*.
### Exemplo 1: negar ações com base em tags de recurso
É possível negar que uma ação seja executada em um recurso com base em tags. O exemplo de política a seguir nega as operações `TagResource`, `UntagResource`, `StartServer`, `StopServer`, `DescribeServer` e `DescribeUser` se o recurso do usuário ou do servidor estiver marcado com a chave `stage` e o valor `prod`.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"transfer:TagResource",
"transfer:UntagResource",
"transfer:StartServer",
"transfer:StopServer",
"transfer:DescribeServer",
"transfer:DescribeUser"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/stage": "prod"
}
}
}
]
}
```
### Exemplo 2: permitir ações com base em tags de recursos
É possível permitir que uma ação seja executada em um recurso com base em tags. O exemplo de política a seguir permite as operações `TagResource`, `UntagResource`, `StartServer`, `StopServer`, `DescribeServer` e `DescribeUser` se o recurso do usuário ou do servidor estiver marcado com a chave `stage` e o valor `prod`.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"transfer:TagResource",
"transfer:UntagResource",
"transfer:StartServer",
"transfer:StopServer",
"transfer:DescribeServer",
"transfer:DescribeUser"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/stage": "prod"
}
}
}
]
}
```
### Exemplo 3: negar a criação de um usuário ou servidor com base em tags de solicitação
O exemplo de política a seguir contém duas declarações. A primeira declaração nega a operação `CreateServer` em todos os recursos se a chave do centro de custo da tag não tiver um valor.
A segunda declaração nega a operação `CreateServer` se a chave do centro de custo da tag contiver qualquer outro valor além de 1, 2 ou 3.
**nota**
Essa política permite criar ou excluir um recurso que contém uma chave chamada `costcenter` e um valor de `1`, `2` ou `3`.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"transfer:CreateServer"
],
"Resource": [
"*"
],
"Condition": {
"Null": {
"aws:RequestTag/costcenter": "true"
}
}
},
{
"Effect": "Deny",
"Action": "transfer:CreateServer",
"Resource": [
"*"
],
"Condition": {
"ForAnyValue:StringNotEquals": {
"aws:RequestTag/costcenter": [
"1",
"2",
"3"
]
}
}
}
]
}
```
# Solução de problemas AWS Transfer Family de identidade e acesso
Use as informações a seguir para ajudá-lo a diagnosticar e corrigir problemas comuns que você pode encontrar ao trabalhar com AWS Transfer Family um IAM.
**Topics**
+ [Não estou autorizado a realizar uma ação em AWS Transfer Family](#security_iam_troubleshoot-no-permissions)
+ [Não estou autorizado a realizar iam: PassRole](#security_iam_troubleshoot-passrole)
+ [Quero permitir que pessoas fora da minha AWS conta acessem meus AWS Transfer Family recursos](#security_iam_troubleshoot-cross-account-access)
## Não estou autorizado a realizar uma ação em AWS Transfer Family
Se isso Console de gerenciamento da AWS indicar que você não está autorizado a realizar uma ação, entre em contato com o administrador para obter ajuda. Caso seu administrador seja a pessoa que forneceu suas credenciais de início de sessão.
O erro de exemplo a seguir ocorre quando o usuário `mateojackson` do IAM tenta usar o console para visualizar detalhes sobre um *widget*, mas não tem as permissões `transfer:GetWidget`.
```
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: transfer:GetWidget on resource: my-example-widget
```
Neste caso, Mateo pede ao administrador para atualizar suas políticas para permitir a ele o acesso ao recurso `my-example-widget` usando a ação `transfer;:GetWidget`.
## Não estou autorizado a realizar iam: PassRole
Se você receber uma mensagem de erro informando que não está autorizado a executar a ação `iam:PassRole`, as suas políticas devem ser atualizadas para permitir que você passe uma função para o AWS Transfer Family.
Alguns Serviços da AWS permitem que você passe uma função existente para esse serviço em vez de criar uma nova função de serviço ou uma função vinculada ao serviço. Para fazê-lo, você deve ter permissões para passar o perfil para o serviço.
O exemplo de erro a seguir ocorre quando uma usuária do IAM chamada `marymajor` tenta utilizar o console para executar uma ação no AWS Transfer Family. No entanto, a ação exige que o serviço tenha permissões concedidas por um perfil de serviço. Mary não tem permissões para passar o perfil para o serviço.
```
User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole
```
Nesse caso, as políticas de Mary devem ser atualizadas para permitir que ela realize a ação `iam:PassRole`.
Se precisar de ajuda, entre em contato com seu AWS administrador. Seu administrador é a pessoa que forneceu suas credenciais de login.
O exemplo de política a seguir contém a permissão para transmitir uma função para AWS Transfer Family. **123456789012**Substitua pelo ID da sua conta da AWS e **MyTransferRole** pelo nome real da sua função do IAM.
****
```
{
"Version":"2012-10-17",
"Statement": [
{ "Action": "iam:PassRole",
"Resource": "arn:aws:iam::123456789012:role/MyTransferRole",
"Effect": "Allow"
}
]
}
```
## Quero permitir que pessoas fora da minha AWS conta acessem meus AWS Transfer Family recursos
É possível criar um perfil que os usuários de outras contas ou pessoas fora da organização podem usar para acessar seus recursos. É possível especificar quem é confiável para assumir o perfil. Para serviços que oferecem suporte a políticas baseadas em recursos ou listas de controle de acesso (ACLs), você pode usar essas políticas para conceder às pessoas acesso aos seus recursos.
Para saber mais, consulte:
+ Para saber se é AWS Transfer Family compatível com esses recursos, consulte[Como AWS Transfer Family funciona com o IAM](security_iam_service-with-iam.md).
+ Para saber como fornecer acesso aos seus recursos em todos os Contas da AWS que você possui, consulte Como [fornecer acesso a um usuário do IAM em outro Conta da AWS que você possui](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html) no *Guia do usuário do IAM*.
+ Para saber como fornecer acesso aos seus recursos a terceiros Contas da AWS, consulte Como [fornecer acesso Contas da AWS a terceiros](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html) no *Guia do usuário do IAM*.
+ Para saber como conceder acesso por meio da federação de identidades, consulte [Conceder acesso a usuários autenticados externamente (federação de identidades)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html) no *Guia do usuário do IAM*.
+ Para saber a diferença entre perfis e políticas baseadas em recurso para acesso entre contas, consulte [Acesso a recursos entre contas no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) no *Guia do usuário do IAM*.
# Chaves de condição do IAM para governança organizacional
AWS Transfer Family fornece chaves de condição do IAM que permitem restringir as configurações de recursos em qualquer política do IAM. Essas chaves de condição podem ser usadas em políticas baseadas em identidade anexadas a usuários ou funções, ou em Políticas de Controle de Serviços (SCPs) para governança organizacional.
As políticas de controle de serviços são políticas do IAM que se aplicam a toda a AWS organização, fornecendo proteções preventivas em várias contas. Quando usadas em SCPs, essas chaves de condição ajudam a impor os requisitos de segurança e conformidade em toda a organização.
**Consulte também**
+ [Ações, recursos e chaves de condição para Transfer Family](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awstransferfamily.html)
+ [Políticas de controle de serviços (SCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html)
+ Vídeo que descreve como aplicar barreiras preventivas usando políticas de controle de serviços
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/mEO05mmbSms)
## Chaves de condição disponíveis
AWS Transfer Family é compatível com as seguintes chaves de condição para uso em políticas do IAM:
`transfer:RequestServerEndpointType`
Restringe a criação e as atualizações do servidor com base no tipo de endpoint (PUBLIC, VPC, VPC\$1ENDPOINT). Comumente usado para evitar endpoints voltados para o público.
`transfer:RequestServerProtocols`
Restringe a criação e as atualizações do servidor com base nos protocolos suportados (SFTP, FTPS, FTP,). AS2
`transfer:RequestServerDomain`
Restringe a criação do servidor com base no tipo de domínio (S3, EFS).
`transfer:RequestConnectorProtocol`
Restringe a criação de conectores com base no protocolo (AS2, SFTP).
## Ações compatíveis
As chaves de condição podem ser aplicadas às seguintes AWS Transfer Family ações:
+ `CreateServer`: Suportes `RequestServerEndpointType` `RequestServerProtocols` e chaves de `RequestServerDomain` condição
+ `UpdateServer`: Suportes `RequestServerEndpointType` e chaves de `RequestServerProtocols` condição
+ `CreateConnector`: Suporta chave de `RequestConnectorProtocol` condição
## Exemplo de política de SCP
O exemplo de SCP a seguir impede a criação de AWS Transfer Family servidores públicos em sua organização:
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "DenyPublicTransferServers",
"Effect": "Deny",
"Action": ["transfer:CreateServer", "transfer:UpdateServer"],
"Resource": "*",
"Condition": {
"StringEquals": {
"transfer:RequestServerEndpointType": "PUBLIC"
}
}
}]
}
```
# Validação de conformidade para AWS Transfer Family
Auditores terceirizados avaliam a segurança e a conformidade AWS Transfer Family como parte de vários programas de AWS conformidade. Isso inclui SOC, PCI, HIPAA e outros. Para ver a lista completa, consulte [AWS Serviços no escopo por programa de conformidade](https://aws.amazon.com/compliance/services-in-scope).
Para obter uma lista de AWS serviços no escopo de programas de conformidade específicos, consulte [AWS serviços no escopo por programa de conformidade](https://aws.amazon.com/compliance/services-in-scope/). Para obter informações gerais, consulte [Programas de conformidade da AWS](https://aws.amazon.com/compliance/programs/).
Você pode baixar relatórios de auditoria de terceiros usando AWS Artifact. Para obter mais informações, consulte [Baixar relatórios em AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html).
Sua responsabilidade de conformidade ao usar AWS Transfer Family é determinada pela confidencialidade de seus dados, pelos objetivos de conformidade de sua empresa e pelas leis e regulamentações aplicáveis. AWS fornece os seguintes recursos para ajudar na conformidade:
+ [Guias de início rápido sobre segurança e conformidade](https://aws.amazon.com/quickstart/?awsf.quickstart-homepage-filter=categories%23security-identity-compliance) — Esses guias de implantação discutem considerações arquitetônicas e fornecem etapas para a implantação de ambientes básicos focados em segurança e conformidade em. AWS
+ Documento técnico [sobre arquitetura para segurança e conformidade com a HIPAA — Este whitepaper](https://docs.aws.amazon.com/whitepapers/latest/architecting-hipaa-security-and-compliance-on-aws/introduction.html) descreve como as empresas podem usar para criar aplicativos compatíveis com a HIPAA. AWS
+ [Recursos de compatibilidade da AWS](https://aws.amazon.com/compliance/resources/): essa coleção de manuais e guias pode ser aplicável a seu setor e local.
+ [AWS Config](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html)— Esse AWS serviço avalia se suas configurações de recursos estão em conformidade com as práticas internas, as diretrizes e os regulamentos do setor.
+ [AWS Security Hub CSPM](https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html)— Esse AWS serviço fornece uma visão abrangente do seu estado de segurança interno, AWS que ajuda você a verificar sua conformidade com os padrões e as melhores práticas do setor de segurança.
# Resiliência em AWS Transfer Family
A infraestrutura AWS global é construída em torno de AWS regiões e zonas de disponibilidade. AWS As regiões fornecem várias zonas de disponibilidade fisicamente separadas e isoladas, conectadas a redes de baixa latência, alta taxa de transferência e alta redundância. Com as zonas de disponibilidade, é possível projetar e operar aplicações e bancos de dados que executam o failover automaticamente entre as zonas de disponibilidade sem interrupção. As zonas de disponibilidade são mais altamente disponíveis, tolerantes a falhas e escaláveis que uma ou várias infraestruturas de data center tradicionais.
AWS Transfer Family suporta até 3 zonas de disponibilidade e é apoiado por uma frota redundante e de escalonamento automático para suas solicitações de conexão e transferência.
Para todos os endpoints da Transfer Family:
+ A redundância em nível de zona de disponibilidade é incorporada ao serviço.
+ Há frotas redundantes para cada AZ.
+ Essa redundância é fornecida automaticamente.
**nota**
Para endpoints em uma Virtual Private Cloud (VPC), é possível fornecer uma única sub-rede. No entanto, recomendamos que você crie endpoints em várias zonas de disponibilidade em sua VPC, para reduzir o risco de interrupções no serviço durante interrupções na zona de disponibilidade.
**Consulte também**
+ Para obter detalhes sobre como criar servidores Transfer Family em uma VPC, consulte. [Crie um servidor em uma VPC (virtual private cloud).](create-server-in-vpc.md)
+ Para obter mais informações sobre zonas de disponibilidade Regiões da AWS e zonas de disponibilidade, consulte [infraestrutura AWS global](https://aws.amazon.com/about-aws/global-infrastructure/).
+ [Para obter um exemplo de como criar maior redundância e minimizar a latência da rede usando o roteamento baseado em latência, consulte a postagem do blog Minimize a latência da rede com seus servidores. AWS Transfer Family](https://aws.amazon.com/blogs/storage/minimize-network-latency-with-your-aws-transfer-for-sftp-servers/)
# Crie uma conexão privada entre uma VPC e AWS Transfer Family APIs
Você pode estabelecer uma conexão privada entre sua VPC e criar uma interface *VPC endpoint*, AWS Transfer Family APIs alimentada por. [AWS PrivateLink](https://aws.amazon.com/privatelink/) Você pode acessar AWS Transfer Family APIs como se estivesse em sua VPC, sem usar um gateway de internet, dispositivo NAT, conexão VPN ou conexão AWS Direct Connect. As instâncias na VPC não precisam de endereços IP públicos para a comunicação com o AWS Transfer Family APIs.
Criaremos um endpoint de interface de rede em cada sub-rede que você habilitar para o endpoint de interface. Para obter mais informações, consulte [Acesse os AWS serviços AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/privatelink-access-aws-services.html) no *AWS PrivateLink Guia*. *Antes de configurar uma interface para o VPC endpoint AWS Transfer Family APIs, leia [as considerações](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#considerations-interface-endpoints) no guia.AWS PrivateLink *
## Controle do acesso usando políticas de VPC endpoint
Por padrão, o acesso total ao AWS Transfer Family APIs é permitido por meio do endpoint. Você pode controlar o acesso ao endpoint de interface usando as políticas de endpoint da VPC. É possível anexar uma política de endpoint ao endpoint da VPC que controla o acesso ao AWS Transfer Family APIs. Essa política especifica as seguintes informações:
+ A **entidade principal** que pode realizar ações.
+ As **ações** que podem ser realizadas.
+ Os **recursos** aos quais as ações podem ser aplicadas.
Para mais informações, consulte [Controlar o acesso a serviços com VPC endpoints](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) no *Guia do usuário da Amazon VPC*.
Veja a seguir um exemplo de uma política de endpoint para AWS Transfer Family APIs. Quando anexada a um endpoint, essa política concede acesso a todas as AWS Transfer Family APIs ações em todos os recursos, exceto aquelas marcadas com chave `Environment` e valor`Test`.
```
{
"Statement": [{
"Effect": "Deny",
"Action": "transfer:StartFileTransfer",
"Principal": "*",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Environment": "Test"
}
}
}, {
"Effect": "Allow",
"Action": "transfer:*",
"Principal": "*",
"Resource": "*"
}]
}
```
## Crie uma interface VPC endpoint para AWS Transfer Family APIs
Você pode criar um VPC endpoint para AWS Transfer Family APIs usar o console Amazon VPC ou a interface de linha de AWS comando ().AWS CLI Para obter mais informações, consulte [Create a VPC endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) (Criar um endpoint da VPC) no *Guia do AWS PrivateLink*.
Crie um VPC endpoint para AWS Transfer Family APIs usar um dos seguintes nomes de serviço:
+ `com.amazonaws.region.transfer`
+ `com.amazonaws.region.transfer-fips`— Criar uma interface VPC endpoint que esteja em conformidade com o padrão do governo dos EUA da publicação 140-3 do Federal Information Processing Standard (FIPS).
Se você habilitar o DNS privado para o endpoint, poderá fazer solicitações de API para o AWS Transfer Family APIs usando seu nome DNS padrão para a região, por exemplo, `transfer.us-east-1.amazonaws.com`.
# Segurança da infraestrutura em AWS Transfer Family
Como serviço gerenciado, AWS Transfer Family é protegido pela segurança de rede AWS global. Para obter informações sobre serviços AWS de segurança e como AWS proteger a infraestrutura, consulte [AWS Cloud Security](https://aws.amazon.com/security/). Para projetar seu AWS ambiente usando as melhores práticas de segurança de infraestrutura, consulte [Proteção](https://docs.aws.amazon.com/wellarchitected/latest/security-pillar/infrastructure-protection.html) de infraestrutura no *Security Pillar AWS Well‐Architected* Framework.
Você usa chamadas de API AWS publicadas para acessar AWS Transfer Family pela rede. Os clientes devem oferecer compatibilidade com:
+ Transport Layer Security (TLS). Exigimos TLS 1.2 e recomendamos TLS 1.3.
+ Conjuntos de criptografia com perfect forward secrecy (PFS) como DHE (Ephemeral Diffie-Hellman) ou ECDHE (Ephemeral Elliptic Curve Diffie-Hellman). A maioria dos sistemas modernos, como Java 7 e versões posteriores, comporta esses modos.
## Evite colocar NLBs e NATs na frente dos AWS Transfer Family servidores
**nota**
Os servidores configurados com os protocolos FTP e FTPS só permitem a configuração com uma VPC: não há endpoint público disponível para FTP/FTPS.
Muitos clientes configuram um Network Load Balancer (NLB) para rotear o tráfego para o servidor. AWS Transfer Family Eles normalmente fazem isso porque criaram seu servidor antes de AWS oferecer uma maneira de acessá-lo de dentro da VPC e da Internet, ou para oferecer suporte a FTP na Internet. Essa configuração não apenas aumenta os custos para os clientes, mas também pode causar outros problemas, que descrevemos nesta seção.
Os gateways NAT são um componente obrigatório quando os clientes estão se conectando a partir de uma rede privada do cliente por trás de um firewall corporativo. No entanto, você deve estar ciente de que, quando muitos clientes estão usando o mesmo gateway NAT, isso pode afetar o desempenho e os limites de conexão. Se houver um NLB ou NAT no caminho de comunicação do cliente para o servidor FTP ou FTPS, o servidor não poderá reconhecer com precisão o endereço IP do cliente, pois AWS Transfer Family vê somente o endereço IP do NLB ou NAT.
Se você estiver usando a configuração de um servidor Transfer Family por trás de um NLB, recomendamos que você mude para um endpoint VPC e use um endereço IP elástico em vez de usar um NLB. Ao usar gateways NAT, esteja ciente das limitações de conexão descritas abaixo.
Se você estiver usando o protocolo FTPS, essa configuração não apenas reduz sua capacidade de auditar quem está acessando seu servidor, mas também pode afetar o desempenho. AWS Transfer Family usa o endereço IP de origem para fragmentar suas conexões em nosso plano de dados. Para FTPS, isso significa que, em vez de ter 10.000 conexões simultâneas, os servidores Transfer Family com gateways NLB ou NAT na rota de comunicação estão limitados a apenas 300 conexões simultâneas.
Embora seja recomendável evitar balanceadores de carga de rede na frente dos AWS Transfer Family servidores, se sua implementação de FTP ou FTPS exigir um NLB ou NAT na rota de comunicação do cliente, siga estas recomendações:
+ Para um NLB, use a porta 21 para verificações de integridade, em vez das portas 8192-8200.
+ Para o AWS Transfer Family servidor, habilite a retomada da sessão TLS configurando. `TlsSessionResumptionMode = ENFORCED`
**nota**
Esse é o modo recomendado, pois fornece segurança aprimorada:
Exige que os clientes usem a retomada da sessão TLS para conexões subsequentes.
Fornece garantias de segurança mais fortes, garantindo parâmetros de criptografia consistentes.
Ajuda a evitar possíveis ataques de downgrade.
Mantém a conformidade com os padrões de segurança e, ao mesmo tempo, otimiza o desempenho.
+ Se possível, deixe de usar um NLB para aproveitar ao máximo os limites de AWS Transfer Family desempenho e conexão.
Para obter orientação adicional sobre alternativas de NLB, entre em contato com a equipe de gerenciamento de AWS Transfer Family produtos por meio do Support AWS . Para obter mais informações sobre como melhorar sua postura de segurança, consulte a postagem do blog [Seis dicas para melhorar a segurança do seu AWS Transfer Family servidor](https://aws.amazon.com/blogs/security/six-tips-to-improve-the-security-of-your-aws-transfer-family-server/).
## Segurança da infraestrutura de conectividade VPC
Os conectores SFTP com tipo de saída VPC fornecem segurança aprimorada da infraestrutura por meio do isolamento da rede e da conectividade privada:
### Benefícios do isolamento de rede
+ **Tráfego de rede privada**: todo o tráfego de conectores para servidores SFTP privados permanece em sua VPC, nunca atravessando a Internet pública.
+ **Saída controlada: para endpoints públicos acessados via VPC, o tráfego é roteado por seus gateways NAT, oferecendo controle sobre endereços IP de saída** e políticas de rede.
+ **Controles de segurança da VPC**: aproveite os grupos de segurança, a rede e as tabelas de rotas da VPC existentes para controlar o acesso à rede ACLs do conector.
+ **Conectividade híbrida**: acesse servidores SFTP locais por meio de conexões VPN ou Direct Connect estabelecidas sem exposição adicional à Internet.
### Considerações de segurança do Resource Gateway
Os gateways de recursos fornecem pontos de entrada seguros para acesso a recursos entre VPCs:
+ **Implantação Multi-AZ**: os gateways de recursos exigem sub-redes em pelo menos duas zonas de disponibilidade para alta disponibilidade e tolerância a falhas.
+ **Controles de grupos** de segurança: configure grupos de segurança para restringir o acesso às portas SFTP (normalmente a porta 22) somente de fontes autorizadas.
+ **Posicionamento de sub-rede privada**: implante gateways de recursos em sub-redes privadas ao se conectar a servidores SFTP privados para manter o isolamento da rede.
+ **Limites de conexão**: cada Resource Gateway suporta até 350 conexões simultâneas com um tempo limite de inatividade de 350 segundos para conexões TCP.
# Adicione um firewall da aplicação web
AWS WAF é um firewall de aplicativos da web que ajuda a proteger os aplicativos da web e APIs contra ataques. É possível usá-lo para configurar um conjunto de regras chamado de *lista de controle de acesso à web* (Web ACL) que permitem, bloqueiam ou contam solicitações da web com base em regras e condições de segurança da web personalizáveis que você define. Para obter mais informações, consulte [Usando AWS WAF para proteger seu APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-aws-waf.html).
**Para adicionar AWS WAF**
1. Abra o console do API Gateway em [https://console.aws.amazon.com/apigateway/](https://console.aws.amazon.com/apigateway/).
1. No painel **APIs**de navegação, escolha seu modelo de provedor de identidade personalizado.
1. Escolha **Estágios**.
1. No painel **Estágios**, escolha o nome do estágio.
1. No painel **Editor de estágio**, escolha a guia **Configurações**.
1. Execute um destes procedimentos:
+ Em **Web Application Firewall (WAF)**, para **Web ACL**, selecione a Web ACL que você deseja associar a esse estágio.
+ Se a Web ACL de que você precisa não existir, você precisará criar uma fazendo o seguinte:
1. Escolha **Criar Web ACL**.
1. Na página inicial do serviço AWS WAF, escolha **Create web ACL**.
1. Em **Detalhes do Web ACL**, em **Nome**, digite o nome do Web ACL.
1. Em **Regras**, escolha **Adicionar regras** e, em seguida, escolha **Adicionar minhas próprias regras e grupos de regras**.
1. **Em Tipo de regra**, escolha conjunto de IPs para identificar uma lista específica de endereços IP.
1. Em **Regra**, insira o nome da regra.
1. Em **conjunto de IPs**, escolha um conjunto de IPs existentes. Para criar um conjunto de IPs, consulte [Criar um conjunto de IPs](https://docs.aws.amazon.com/waf/latest/developerguide/waf-ip-set-creating.html).
1. Em **Endereço IP para usar como endereço de origem**, escolha **endereço IP no cabeçalho**.
1. Em **Nome do campo de cabeçalho**, insira `SourceIP`.
1. Em **Posição dentro do cabeçalho**, escolha **Primeiro endereço IP**.
1. Em **Fallback para endereço IP ausente**, escolha **Corresponder** ou **Não corresponder**, dependendo de como você deseja lidar com um endereço IP inválido (ou ausente) no cabeçalho.
1. Em **Ação**, escolha a ação do conjunto de IPs.
1. Em **Ação de Web ACL padrão para solicitações que não correspondem a nenhuma regra**, escolha **Permitir** ou **Bloquear** e clique em **Avançar**.
1. Para as etapas 4 e 5, escolha **Avançar**.
1. Em **Revisar e criar**, revise suas escolhas e escolha **Criar Web ACL**.
1. Escolha **Salvar alterações**.
1. Escolha **Recursos**.
1. Escolha **Ações** e **Implantar API**.
Para obter informações sobre como proteger o Transfer Family com o firewall de aplicativos AWS web, consulte [Protegendo o Transfer Family com o firewall do AWS aplicativo e o Amazon API Gateway](https://aws.amazon.com/blogs/storage/securing-aws-transfer-family-with-aws-web-application-firewall-and-amazon-api-gateway/) no blog AWS de armazenamento.
# Prevenção do problema do “confused deputy” entre serviços
O problema "confused deputy" é um problema de segurança em que uma entidade que não tem permissão para executar uma ação pode coagir uma entidade mais privilegiada a executar a ação. Em AWS, a falsificação de identidade entre serviços pode resultar em um problema confuso de delegado. A personificação entre serviços pode ocorrer quando um serviço (o *serviço de chamada*) chama outro serviço (o *serviço chamado*). O serviço de chamada pode ser manipulado de modo a usar suas permissões para atuar nos recursos de outro cliente de uma forma na qual ele não deveria ter permissão para acessar. Para evitar isso, a AWS fornece ferramentas que ajudam você a proteger seus dados para todos os serviços com entidades principais de serviço que receberam acesso aos recursos em sua conta. Para obter uma descrição detalhada desse problema, consulte [o problema de “confused deputy”](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) no *Guia do usuário do IAM*.
Recomendamos usar as chaves de contexto de condição [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)global [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)e as chaves de contexto nas políticas de recursos para limitar as permissões que a AWS Transfer Family tem para o recurso. Se você utilizar ambas as chaves de contexto de condição global, o valor `aws:SourceAccount` e a conta `aws:SourceArn` no valor deverão utilizar o mesmo ID de conta quando utilizados na mesma instrução de política.
A maneira mais eficaz de se proteger contra o problema do “confused deputy” é usar o nome do recurso da Amazon (ARN) exato do recurso que você deseja permitir. Se você estiver especificando vários recursos, use a chave de condição de contexto global `aws:SourceArn` com caracteres curingas (`*`) para as partes desconhecidas do ARN. Por exemplo, .`arn:aws:transfer::region::account-id:server/*`
AWS O Transfer Family usa os seguintes tipos de funções:
+ **Função de usuário** — Permite que usuários gerenciados pelo serviço acessem os recursos necessários do Transfer Family. AWS Transfer Family assume essa função no contexto de um ARN de usuário do Transfer Family.
+ **Função de acesso**: fornece acesso apenas aos arquivos do Amazon S3 que estão sendo transferidos. Para AS2 transferências de entrada, a função de acesso usa o Amazon Resource Name (ARN) para o contrato. Para AS2 transferências de saída, a função de acesso usa o ARN para o conector.
+ **Função de invocação**: para uso com o Amazon API Gateway como provedor de identidade personalizada do servidor. O Transfer Family assume essa função no contexto de um ARN do servidor do Transfer Family.
+ **Função de registro** — usada para registrar entradas na Amazon CloudWatch. O Transfer Family usa essa função para registrar em log os detalhes de sucesso e falha com informações sobre transferências de arquivos. O Transfer Family assume essa função no contexto de um ARN do servidor do Transfer Family. Para AS2 transferências de saída, a função de registro usa o ARN do conector.
+ **Função de execução**: permite que um usuário do Transfer Family chame e inicie fluxos de trabalho. O Transfer Family assume essa função no contexto de um ARN de fluxo de trabalho do Transfer Family.
Para obter mais informações, consulte [Políticas e permissões no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) no *Guia do usuário do IAM*.
**nota**
Nos exemplos a seguir, substitua cada um *user input placeholder* por suas próprias informações.
**nota**
Em nossos exemplos, usamos tanto `ArnLike` quanto `ArnEquals`. Eles são funcionalmente idênticos, portanto, é possível usá-los ao criar suas políticas. A documentação do Transfer Family usa `ArnLike` quando a condição contém um caractere curinga, e `ArnEquals` para indicar uma condição de correspondência exata.
## AWS A função de usuário do Transfer Family entre serviços confundiu a prevenção adjunta
O exemplo de política a seguir permite que qualquer usuário de qualquer servidor na conta assuma a função.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "transfer.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:transfer:us-east-1:123456789012:user/*"
}
}
}
]
}
```
O exemplo de política a seguir permite que qualquer usuário de um servidor específico assuma a função.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "transfer.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012"
},
"ArnEquals": {
"aws:SourceArn": "arn:aws:transfer:us-east-1:123456789012:user/server-id/*"
}
}
}
]
}
```
O exemplo de política a seguir permite que um usuário específico de um servidor específico assuma a função.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "transfer.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:transfer:us-east-1:123456789012:user/server-id/user-name"
}
}
}
]
}
```
## AWS Transfer Family: função de fluxo de trabalho entre serviços, prevenção delegada confusa
O exemplo de política a seguir permite que qualquer fluxo de trabalho na conta assuma a função.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "transfer.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:transfer:us-west-2:111122223333:workflow/*"
}
}
}
]
}
```
O exemplo de política a seguir permite que um fluxo de trabalho específico assuma a função.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "transfer.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:transfer:us-west-2:111122223333:workflow/workflow-id"
}
}
}
]
}
```
## AWS A função do conector Transfer Family entre serviços confundiu a prevenção adjunta
O exemplo de política a seguir permite que qualquer conector na conta assuma a função.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "transfer.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:transfer:us-east-1:123456789012:connector/*"
}
}
}
]
}
```
O exemplo de política a seguir permite que um conector específico assuma a função.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "transfer.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:transfer:us-east-1:123456789012:connector/connector-id"
}
}
}
]
}
```
## AWS Transfer Family: a função de registro e invocação entre serviços confundiu a prevenção adjunta
**nota**
Os exemplos a seguir podem ser usados nas funções de registro e de invocação.
Nesses exemplos, você pode remover os detalhes do ARN de um fluxo de trabalho se o servidor não tiver nenhum fluxo de trabalho vinculado a ele.
O exemplo de logging/invocation política a seguir permite que qualquer servidor (e fluxo de trabalho) na conta assuma a função.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAllServersWithWorkflowAttached",
"Effect": "Allow",
"Principal": {
"Service": "transfer.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333"
},
"ArnLike": {
"aws:SourceArn": [
"arn:aws:transfer:us-west-2:111122223333:server/*",
"arn:aws:transfer:us-west-2:111122223333:workflow/*"
]
}
}
}
]
}
```
O exemplo de logging/invocation política a seguir permite que um servidor específico (e fluxo de trabalho) assuma a função.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowSpecificServerWithWorkflowAttached",
"Effect": "Allow",
"Principal": {
"Service": "transfer.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333"
},
"ArnEquals": {
"aws:SourceArn": [
"arn:aws:transfer:us-west-2:111122223333:server/server-id",
"arn:aws:transfer:us-west-2:111122223333:workflow/workflow-id"
]
}
}
}
]
}
```
# AWS políticas gerenciadas para AWS Transfer Family
Para adicionar permissões a usuários, grupos e funções, é mais fácil usar políticas AWS gerenciadas do que escrever políticas você mesmo. É preciso tempo e experiência para [criar AWS Identity and Access Management (IAM) políticas gerenciadas pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) que forneçam à sua equipe apenas as permissões de que precisam. Para começar rapidamente, você pode usar nossas políticas AWS gerenciadas. Essas políticas abrangem casos de uso comuns e estão disponíveis na sua Conta da AWS. Para obter mais informações sobre as políticas gerenciadas da AWS , consulte [Políticas gerenciadas da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) no *Guia do usuário do IAM*. Para obter uma lista detalhada de todas as políticas AWS gerenciadas, consulte o [guia de referência de políticas AWS gerenciadas](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/about-managed-policy-reference.html).
AWS os serviços mantêm e atualizam as políticas AWS gerenciadas. Você não pode alterar as permissões nas políticas AWS gerenciadas. Os serviços ocasionalmente acrescentam permissões adicionais a uma política gerenciada pela AWS para oferecer suporte a novos recursos. Esse tipo de atualização afeta todas as identidades (usuários, grupos e funções) em que a política está anexada. É mais provável que os serviços atualizem uma política gerenciada pela AWS quando um novo recurso for iniciado ou novas operações se tornarem disponíveis. Os serviços não removem as permissões de uma política AWS gerenciada, portanto, as atualizações de políticas não violarão suas permissões existentes.
Além disso, AWS oferece suporte a políticas gerenciadas para funções de trabalho que abrangem vários serviços. Por exemplo, a política `ReadOnlyAccess` AWS gerenciada fornece acesso somente de leitura a todos os AWS serviços e recursos. Quando um serviço lança um novo recurso, AWS adiciona permissões somente de leitura para novas operações e recursos. Para obter uma lista e descrições das políticas de perfis de trabalho, consulte [Políticas gerenciadas pela AWS para perfis de trabalho](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) no *Guia do usuário do IAM*.
## AWS política gerenciada: AWSTransfer ConsoleFullAccess
A `AWSTransferConsoleFullAccess` política fornece acesso total ao Transfer Family por meio do AWS Management Console. Para obter mais informações, consulte [Função vinculada ao serviço para AWS Transfer Family](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSTransferConsoleFullAccess.html).
## AWS política gerenciada: AWSTransfer FullAccess
A política `AWSTransferFullAccess` concede acesso total aos serviços do Transfer Family. Para obter mais informações, consulte [Função vinculada ao serviço para AWS Transfer Family](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSTransferFullAccess.html).
## AWS política gerenciada: AWSTransfer LoggingAccess
A `AWSTransferLoggingAccess` política concede à AWS Transfer Family acesso total para criar fluxos e grupos de registros e colocar eventos de registro em sua conta. Para obter mais informações, consulte [Função vinculada ao serviço para AWS Transfer Family](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSTransferLoggingAccess.html).
## AWS política gerenciada: AWSTransfer ReadOnlyAccess
A política `AWSTransferReadOnlyAccess` concede acesso somente leitura aos serviços do Transfer Family. Para obter mais informações, consulte [Função vinculada ao serviço para AWS Transfer Family](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSTransferReadOnlyAccess.html).
## AWS Transfer Family atualiza as políticas AWS gerenciadas
Veja detalhes sobre as atualizações das políticas AWS gerenciadas do AWS Transfer Family desde que esse serviço começou a rastrear essas alterações. Para obter alertas automáticos sobre alterações feitas nesta página, inscreva-se no feed RSS na página [Histórico do documento para AWS Transfer Family](doc-history.md).
| Alteração | Descrição | Data |
| --- | --- | --- |
| Atualização da documentação | Seções adicionadas para cada uma das políticas gerenciadas pelo Transfer Family. | 27 de janeiro de 2022 |
| [AWSTransferReadOnlyAccess](#security-iam-awsmanpol-transferreadonlyaccess) – atualização para uma política existente | AWS A Transfer Family adicionou novas permissões para permitir a leitura da política AWS Managed Microsoft AD. | 30 de setembro de 2021 |
| AWS Transfer Family começou a monitorar as alterações | AWS A Transfer Family começou a monitorar as mudanças em suas políticas AWS gerenciadas. | 15 de junho de 2021 |