Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Sécurité dans AWS Transfer Family
La sécurité du cloud AWS est la priorité absolue. En tant que AWS client, vous bénéficiez d'un centre de données et d'une architecture réseau conçus pour répondre aux exigences des entreprises les plus sensibles en matière de sécurité.
La sécurité est une responsabilité partagée entre vous AWS et vous. Le [modèle de responsabilité partagée](https://aws.amazon.com/compliance/shared-responsibility-model/) décrit cette notion par les termes sécurité *du* cloud et sécurité *dans* le cloud :
Pour savoir si un [programme Services AWS de conformité Service AWS s'inscrit dans le champ d'application de programmes de conformité](https://aws.amazon.com/compliance/services-in-scope/) spécifiques, consultez Services AWS la section de conformité et sélectionnez le programme de conformité qui vous intéresse. Pour des informations générales, voir Programmes de [AWS conformité Programmes AWS](https://aws.amazon.com/compliance/programs/) de .
Vous pouvez télécharger des rapports d'audit tiers à l'aide de AWS Artifact. Pour plus d'informations, voir [Téléchargement de rapports dans AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html) .
Votre responsabilité en matière de conformité lors de l'utilisation Services AWS est déterminée par la sensibilité de vos données, les objectifs de conformité de votre entreprise et les lois et réglementations applicables. Pour plus d'informations sur votre responsabilité en matière de conformité lors de l'utilisation Services AWS, consultez [AWS la documentation de sécurité](https://docs.aws.amazon.com/security/).
Cette documentation vous aide à comprendre comment appliquer le modèle de responsabilité partagée lors de son utilisation AWS Transfer Family. Les rubriques suivantes expliquent comment procéder à la configuration AWS Transfer Family pour atteindre vos objectifs de sécurité et de conformité. Vous apprendrez également à utiliser d'autres AWS services qui vous aident à surveiller et à sécuriser vos AWS Transfer Family ressources.
Nous proposons un atelier qui fournit des conseils prescriptifs et un laboratoire pratique sur la manière de créer une architecture de transfert de fichiers évolutive et sécurisée AWS sans avoir à modifier les applications existantes ou à gérer l'infrastructure de serveurs. Vous pouvez consulter les détails de cet atelier [ici](https://catalog.workshops.aws/basic-security-workshop-transfer-family/en-US).
**Topics**
+ [Avantages de la connectivité VPC en termes de sécurité](#vpc-connectivity-security)
+ [Politiques de sécurité pour les AWS Transfer Family serveurs](security-policies.md)
+ [Politiques de sécurité pour les AWS Transfer Family connecteurs SFTP](security-policies-connectors.md)
+ [Utilisation de l'échange de clés post-quantique hybride avec AWS Transfer Family](post-quantum-security-policies.md)
+ [Protection et chiffrement des données](encryption-at-rest.md)
+ [Gestion des clés SSH et PGP dans Transfer Family](key-management.md)
+ [Gestion des identités et des accès pour AWS Transfer Family](security-iam.md)
+ [Validation de conformité pour AWS Transfer Family](transfer-compliance.md)
+ [Résilience dans AWS Transfer Family](disaster-recovery-resiliency.md)
+ [Créez une connexion privée entre un VPC et AWS Transfer Family APIs](vpc-api-endpoints.md)
+ [Sécurité de l'infrastructure dans AWS Transfer Family](infrastructure-security.md)
+ [Ajouter un pare-feu pour applications Web](web-application-firewall.md)
+ [Prévention du problème de l’adjoint confus entre services](confused-deputy.md)
+ [AWS politiques gérées pour AWS Transfer Family](security-iam-awsmanpol.md)
## Avantages de la connectivité VPC en termes de sécurité
Les connecteurs SFTP avec sortie VPC offrent des avantages de sécurité améliorés grâce à un accès aux ressources inter-VPC :
+ **Isolation du réseau** : tout le trafic reste dans votre environnement VPC, ce qui permet une isolation complète du réseau par rapport à l'Internet public pour les connexions de points de terminaison privés.
+ **Contrôle IP source** : les serveurs SFTP distants ne voient que les adresses IP de votre plage d'adresses CIDR VPC, ce qui vous donne un contrôle total sur les adresses IP source utilisées pour les connexions.
+ **Accès aux terminaux privés** : connectez-vous directement aux serveurs SFTP de votre VPC à l'aide d'adresses IP privées, éliminant ainsi toute exposition à l'Internet public.
+ **Connectivité hybride** : accédez en toute sécurité aux serveurs SFTP sur site via des connexions VPN ou Direct Connect établies, sans exposition supplémentaire à Internet.
+ **Contrôles de sécurité VPC** : Tirez parti des groupes de sécurité VPC existants et des politiques de routage pour contrôler et surveiller le trafic des connecteurs SFTP. NACLs
### Modèle de sécurité VPC Lattice
La connectivité VPC pour les connecteurs SFTP utilise le réseau AWS VPC Lattice avec des réseaux de services pour fournir un accès mutualisé sécurisé :
+ **Prévention de la confusion chez les adjoints** : les contrôles d'authentification et d'autorisation garantissent que les connecteurs ne peuvent accéder qu'aux ressources spécifiques pour lesquelles ils sont configurés, empêchant ainsi tout accès non autorisé entre locataires.
+ **IPv6réseau de services uniquement** : utilise l' IPv6adressage pour éviter les conflits d'adresses IP potentiels et améliorer l'isolation de sécurité.
+ **Session d'accès direct (FAS)** : la gestion temporaire des informations d'identification élimine le besoin de stockage à long terme des informations d'identification ou de partage manuel des ressources.
+ **Contrôle d'accès au niveau des ressources** : chaque connecteur est associé à une configuration de ressources spécifique, garantissant un contrôle d'accès granulaire aux serveurs SFTP individuels.
### Bonnes pratiques de sécurité pour la connectivité VPC
Lorsque vous utilisez des connecteurs de sortie VPC, suivez les meilleures pratiques de sécurité suivantes :
+ **Groupes de sécurité** : configurez les groupes de sécurité pour autoriser le trafic SFTP (port 22) uniquement entre les ressources nécessaires. Limitez les plages d'adresses IP source et de destination au minimum requis.
+ **Emplacement des passerelles** de ressources : déployez les passerelles de ressources dans des sous-réseaux privés lorsque cela est possible, et assurez-vous qu'elles s'étendent sur au moins deux zones de disponibilité pour garantir une haute disponibilité.
+ **Surveillance du réseau** : utilisez les journaux de flux VPC et Amazon CloudWatch pour surveiller les modèles de trafic réseau et détecter les activités anormales.
+ **Journalisation des accès** : activez la journalisation des connecteurs pour suivre les activités de transfert de fichiers et gérer les pistes d'audit relatives aux exigences de conformité.
+ **Gestion de la configuration des ressources** : passez régulièrement en revue et mettez à jour les configurations des ressources pour vous assurer qu'elles pointent vers les serveurs SFTP appropriés et qu'elles utilisent les paramètres réseau appropriés.
# Politiques de sécurité pour les AWS Transfer Family serveurs
Les politiques de sécurité du serveur vous AWS Transfer Family permettent de limiter l'ensemble des algorithmes cryptographiques (codes d'authentification des messages (MACs), échanges de clés (KEXs), suites de chiffrement, chiffrements de contenu et algorithmes de hachage) associés à votre serveur.
AWS Transfer Family prend en charge les politiques de sécurité post-quantique qui utilisent des algorithmes d'échange de clés hybrides, combinant des méthodes cryptographiques traditionnelles avec des algorithmes post-quantiques pour renforcer la sécurité contre les futures menaces informatiques quantiques. Les détails sont fournis dans[Utilisation de l'échange de clés post-quantique hybride avec AWS Transfer Family](post-quantum-security-policies.md).
Pour obtenir la liste des algorithmes cryptographiques pris en charge, consultez[Algorithmes cryptographiques](#cryptographic-algorithms). Pour obtenir la liste des algorithmes clés pris en charge à utiliser avec les clés d'hôte du serveur et les clés utilisateur gérées par les services, consultez. [Gestion des clés SSH et PGP dans Transfer Family](key-management.md)
**Note**
Nous vous recommandons vivement de mettre vos serveurs à jour conformément à notre politique de sécurité la plus récente.
`TransferSecurityPolicy-2024-01`est la politique de sécurité par défaut attachée à votre serveur lorsque vous créez un serveur à l'aide de la console, de l'API ou de la CLI.
Si vous créez un serveur Transfer Family en utilisant CloudFormation et acceptez la politique de sécurité par défaut, le serveur est assigné`TransferSecurityPolicy-2018-11`.
Si la compatibilité des clients vous préoccupe, veuillez indiquer clairement la politique de sécurité que vous souhaitez utiliser lors de la création ou de la mise à jour d'un serveur plutôt que d'utiliser la politique par défaut, qui est sujette à modification. Pour modifier la politique de sécurité d'un serveur, consultez[Modifier la politique de sécurité](edit-server-config.md#edit-cryptographic-algorithm).
Pour plus d'informations sur la sécurité dans Transfer Family, consultez les articles de blog suivants :
+ [Six conseils pour améliorer la sécurité de votre AWS Transfer Family serveur](https://aws.amazon.com/blogs/security/six-tips-to-improve-the-security-of-your-aws-transfer-family-server/)
+ [Comment Transfer Family peut vous aider à créer une solution de transfert de fichiers géré sécurisée et conforme](https://aws.amazon.com/blogs/security/how-transfer-family-can-help-you-build-a-secure-compliant-managed-file-transfer-solution/)
**Topics**
+ [Algorithmes cryptographiques](#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-03](#security-policy-transfer-2022-03)
+ [TransferSecurityPolicy-2020-06 et -Restricté-2020-06 TransferSecurityPolicy](#security-policy-transfer-2020-06)
+ [TransferSecurityPolicy-2018-11 et -Restricté-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 Restreint-2025-07](#as2-restricted-policy)
+ [Politiques de sécurité post-Quantum](#pq-policies)
## Algorithmes cryptographiques
Pour les clés d'hôte, nous prenons en charge les algorithmes suivants :
+ `rsa-sha2-256`
+ `rsa-sha2-512`
+ `ecdsa-sha2-nistp256`
+ `ecdsa-sha2-nistp384`
+ `ecdsa-sha2-nistp521`
+ `ssh-ed25519`
En outre, les politiques de sécurité suivantes permettent `ssh-rsa` :
+ TransferSecurityPolicy-2018-11
+ TransferSecurityPolicy-2020-06
+ TransferSecurityPolicy-FIPS-2020-06
+ TransferSecurityPolicy-FIPS-2023-05
+ TransferSecurityPolicy-FIPS-2024-01
+ TransferSecurityPolicy-PQ-SSH-FIPS-Expérimental-2023-04
**Note**
Il est important de comprendre la distinction entre le type de clé RSA (qui est toujours le cas) `ssh-rsa` et l'algorithme de clé d'hôte RSA, qui peut être n'importe lequel des algorithmes pris en charge.
Vous trouverez ci-dessous une liste des algorithmes cryptographiques pris en charge pour chaque politique de sécurité.
**Note**
Dans le tableau et les politiques suivants, notez l'utilisation suivante des types d'algorithmes.
Les serveurs SFTP utilisent uniquement des algorithmes dans les **SshMacs**sections **SshCiphers**SshKexs****, et.
Les serveurs FTPS utilisent uniquement les algorithmes de **TlsCiphers**cette section.
Les serveurs FTP, puisqu'ils n'utilisent pas de chiffrement, n'utilisent aucun de ces algorithmes.
AS2 les serveurs utilisent uniquement des algorithmes dans les **HashAlgorithms**sections **ContentEncryptionCiphers**et. Ces sections définissent les algorithmes utilisés pour chiffrer et signer le contenu des fichiers.
Les politiques de sécurité FIPS-2024-05 et FIPS-2024-01 sont identiques, sauf que la norme FIPS-2024-05 ne prend pas en charge l'algorithme. `ssh-rsa`
Transfer Family a introduit de nouvelles politiques restreintes qui sont étroitement parallèles aux politiques existantes :
Les politiques de sécurité TransferSecurityPolicy -Restricted-2018-11 et TransferSecurityPolicy -2018-11 sont identiques, sauf que la politique restreinte ne prend pas en charge le chiffrement. `chacha20-poly1305@openssh.com`
Les politiques de sécurité TransferSecurityPolicy -Restricted-2020-06 et TransferSecurityPolicy -2020-06 sont identiques, sauf que la politique restreinte ne prend pas en charge le chiffrement. `chacha20-poly1305@openssh.com`
\$1 Dans le tableau suivant, le `chacha20-poly1305@openssh.com` chiffrement est inclus uniquement dans la politique non restreinte,
| Politique de sécurité | 2024-01 | SshAuditCompliant-2025-02 | 2023-05 | 05.03 | **2020-06** **Restreint au 06/2020** | **FIPS-2024-05** **FIPS-2024-01** | FIPS-2023-05 | FIPS-2020-06 | **2018-11** **restreint pour 2018-11** | TransferSecurityPolicy- AS2 Restreint-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-nistp255 | ♦ | | | | ♦ | ♦ | | ♦ | ♦ | ♦ |
| 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@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\$1WITH\$1AES\$1128\$1CBC\$1 SHA256 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1ECDSA\$1AVEC\$1AES\$1128\$1GCM\$1 SHA256 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA384 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1GCM\$1 SHA384 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1 SHA256 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1GCM\$1 SHA256 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA384 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1GCM\$1 SHA384 | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ | ♦ |
| TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1 SHA256 | | | | | | | | | ♦ | |
| TLS\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA256 | | | | | | | | | ♦ | |
## TransferSecurityPolicy-2024-01
Voici la politique de sécurité TransferSecurityPolicy -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
Ce qui suit montre la politique de TransferSecurityPolicy sécurité - SshAuditCompliant -2025-02.
**Note**
Cette politique de sécurité est conçue autour des recommandations fournies par l'`ssh-audit`outil et est 100 % conforme à cet outil.
```
{
"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
Ce qui suit montre la politique de TransferSecurityPolicy sécurité -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-03
Ce qui suit montre la politique de sécurité TransferSecurityPolicy -03.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 et -Restricté-2020-06 TransferSecurityPolicy
Voici la politique de sécurité TransferSecurityPolicy -2020-06.
**Note**
Les politiques de sécurité TransferSecurityPolicy -Restricted-2020-06 et TransferSecurityPolicy -2020-06 sont identiques, sauf que la politique restreinte ne prend pas en charge le chiffrement. `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 et -Restricté-2018-11 TransferSecurityPolicy
Voici la politique de sécurité TransferSecurityPolicy -2018-11.
**Note**
Les politiques de sécurité TransferSecurityPolicy -Restricted-2018-11 et TransferSecurityPolicy -2018-11 sont identiques, sauf que la politique restreinte ne prend pas en charge le chiffrement. `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
Vous trouverez ci-dessous les politiques de sécurité -FIPS-2024-01 et TransferSecurityPolicy -FIPS-2024-05. TransferSecurityPolicy
**Note**
Le point de terminaison du service FIPS et les politiques de sécurité TransferSecurityPolicy -FIPS-2024-01 et TransferSecurityPolicy -FIPS-2024-05 ne sont disponibles que dans certaines régions. AWS Pour plus d’informations, consultez [Points de terminaison et quotas AWS Transfer Family](https://docs.aws.amazon.com/general/latest/gr/transfer-service.html) dans le document *Références générales AWS*.
La seule différence entre ces deux politiques de sécurité est que TransferSecurityPolicy -FIPS-2024-01 supporte l'`ssh-rsa`algorithme, alors que -FIPS-2024-05 ne le fait pas. 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
Les détails de la certification FIPS sont AWS Transfer Family disponibles à l'adresse [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)
Voici la politique de sécurité TransferSecurityPolicy -FIPS-2023-05.
**Note**
Le point de terminaison du service FIPS et la politique de sécurité TransferSecurityPolicy -FIPS-2023-05 ne sont disponibles que dans certaines régions. AWS Pour plus d’informations, consultez [Points de terminaison et quotas AWS Transfer Family](https://docs.aws.amazon.com/general/latest/gr/transfer-service.html) dans le document *Références générales 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
Les détails de la certification FIPS sont AWS Transfer Family disponibles à l'adresse [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)
Voici la politique de sécurité TransferSecurityPolicy -FIPS-2020-06.
**Note**
Le point de terminaison du service FIPS et la politique de sécurité TransferSecurityPolicy -FIPS-2020-06 ne sont disponibles que dans certaines régions. AWS Pour plus d’informations, consultez [Points de terminaison et quotas AWS Transfer Family](https://docs.aws.amazon.com/general/latest/gr/transfer-service.html) dans le document *Références générales 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 Restreint-2025-07
Cette politique de sécurité est conçue pour les transferts de AS2 fichiers qui nécessitent une sécurité renforcée en excluant les algorithmes cryptographiques existants. Il prend en charge le chiffrement AES moderne et les algorithmes de hachage SHA-2 tout en supprimant le support des algorithmes plus faibles tels que 3DES et 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"
]
}
}
```
## Politiques de sécurité post-Quantum
Ce tableau répertorie les algorithmes utilisés pour les politiques de sécurité post-quantique de Transfer Family. Ces politiques sont décrites en détail dans[Utilisation de l'échange de clés post-quantique hybride avec AWS Transfer Family](post-quantum-security-policies.md).
Les listes de politiques suivent le tableau.
**Note**
**Les politiques quantiques du post précédent (**TransferSecurityPolicy-PQ-SSH-Experimental-2023-04 et -PQ-SSH-FIPS-Experimental-2023-04**) sont obsolètes. TransferSecurityPolicy** Nous vous recommandons plutôt d'utiliser les nouvelles politiques.
| Politique de sécurité | 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-nistp255 | ♦ | ♦ |
| 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\$1WITH\$1AES\$1128\$1CBC\$1 SHA256 | ♦ | ♦ |
| TLS\$1ECDHE\$1ECDSA\$1AVEC\$1AES\$1128\$1GCM\$1 SHA256 | ♦ | ♦ |
| TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA384 | ♦ | ♦ |
| TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1GCM\$1 SHA384 | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1 SHA256 | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1GCM\$1 SHA256 | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA384 | ♦ | ♦ |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1GCM\$1 SHA384 | ♦ | ♦ |
### TransferSecurityPolicy-2025-03
Voici la politique de sécurité 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
Voici la politique de sécurité 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 Restreint-2025-07
Ce qui suit montre la politique de sécurité TransferSecurityPolicy - AS2 Restricted-2025-07.
**Note**
Cette politique de sécurité est identique à la politique TransferSecurityPolicy -2025-03, sauf qu'elle ne prend pas en charge 3DES (in ContentEncryptionCiphers) ni (in). SHA1 HashAlgorithms Il inclut tous les algorithmes de 2025-03, y compris les algorithmes cryptographiques post-quantiques (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"
]
}
}
```
# Politiques de sécurité pour les AWS Transfer Family connecteurs SFTP
Les politiques de sécurité du connecteur SFTP vous AWS Transfer Family permettent de limiter l'ensemble des algorithmes cryptographiques (codes d'authentification des messages (MACs), échanges de clés (KEXs) et suites de chiffrement) associés à votre connecteur SFTP. Voici une liste des algorithmes cryptographiques pris en charge pour chaque politique de sécurité du connecteur SFTP.
**Note**
`TransferSFTPConnectorSecurityPolicy-2024-03`est la politique de sécurité par défaut appliquée aux connecteurs SFTP.
Vous pouvez modifier la politique de sécurité de votre connecteur. Sélectionnez **Connectors** dans le volet de navigation de gauche de Transfer Family, puis sélectionnez votre connecteur. Sélectionnez ensuite **Modifier** dans la section de **configuration Sftp**. Dans la section **Options de l'algorithme cryptographique**, choisissez n'importe quelle politique de sécurité disponible dans la liste déroulante du champ **Politique de sécurité**.
## Algorithmes cryptographiques
Pour les clés d'hôte, les connecteurs SFTP prennent en charge tous les algorithmes pris en charge par les serveurs Transfer Family, à l'exception de ed25519 :
+ `rsa-sha2-256`
+ `rsa-sha2-512`
+ `ecdsa-sha2-nistp256`
+ `ecdsa-sha2-nistp384`
+ `ecdsa-sha2-nistp521`
De plus, pour les clés d'hôte, nous prenons en charge`ssh-rsa`, mais uniquement pour`TransferSFTPConnectorSecurityPolicy-2023-07`.
Pour l'authentification, les connecteurs SFTP prennent en charge les types de clés suivants :
+ `ssh-rsa`
+ `ecdsa`
## Détails de la politique de sécurité du connecteur SFTP
Le tableau suivant indique les algorithmes cryptographiques spécifiques pris en charge par chaque politique de sécurité du connecteur SFTP.
| Politique de sécurité | Transfert SFTPConnector SecurityPolicy -FIPS-2024-10 | Transfert SFTPConnector SecurityPolicy -2024-03 | Transfert 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-nistp255 | ♦ | | |
| 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-nistp255 | ♦ | ♦ | ♦ |
| ecdsa-sha2-nistp384 | | ♦ | ♦ |
| ecdsa-sha2-nistp521 | | ♦ | ♦ |
| ssh-rsa | | | ♦ |
# Utilisation de l'échange de clés post-quantique hybride avec AWS Transfer Family
Transfer Family prend en charge une option hybride d'établissement de clés post-quantiques pour le protocole Secure Shell (SSH). L'établissement d'une clé post-quantique est nécessaire car il est déjà possible d'enregistrer le trafic réseau et de le sauvegarder pour le déchiffrer à l'avenir par un ordinateur quantique, ce que l'on appelle une *store-now-harvest-later*attaque.
Vous pouvez utiliser cette option lorsque vous vous connectez à Transfer Family pour des transferts de fichiers sécurisés vers et depuis le stockage Amazon Simple Storage Service (Amazon S3) ou Amazon Elastic File System (Amazon EFS). L'établissement de clés hybrides post-quantiques dans SSH introduit des mécanismes d'établissement de clés post-quantiques, qu'il utilise conjointement avec des algorithmes d'échange de clés classiques. Les clés SSH créées à l'aide de suites de chiffrement classiques sont protégées contre les attaques par force brute grâce à la technologie actuelle. Cependant, le chiffrement classique ne devrait pas rester sécurisé après l'émergence de l'informatique quantique à grande échelle dans le futur.
Si votre organisation compte sur la confidentialité à long terme des données transmises via une connexion Transfer Family, vous devriez envisager de passer à la cryptographie post-quantique avant que des ordinateurs quantiques à grande échelle ne soient disponibles.
Afin de protéger les données chiffrées aujourd'hui contre d'éventuelles attaques futures, AWS participe avec la communauté cryptographique au développement d'algorithmes résistants aux quanta ou post-quantiques. Nous avons mis en œuvre des suites de chiffrement hybrides par échange de clés post-quantiques dans Transfer Family qui combinent des éléments classiques et post-quantiques.
Ces suites de chiffrement hybrides peuvent être utilisées sur vos charges de travail de production dans la plupart AWS des régions. Cependant, étant donné que les caractéristiques de performance et les exigences en bande passante des suites de chiffrement hybrides sont différentes de celles des mécanismes d'échange de clés classiques, nous vous recommandons de les tester sur vos connexions Transfer Family.
Pour en savoir plus sur la cryptographie post-quantique, consultez le billet de blog sur la [sécurité post-quantique](https://aws.amazon.com/security/post-quantum-cryptography/).
**Contents**
+ [À propos de l'échange de clés hybrides post-quantiques en SSH](#pq-about-key-exchange)
+ [Comment fonctionne l'établissement de clés hybrides post-quantiques dans Transfer Family](#pqtls-details)
+ [Pourquoi ML-KEM ?](#why-mlkem)
+ [Échange de clés SSH hybride post-quantique et exigences cryptographiques (FIPS 140)](#pq-alignment)
+ [Test de l'échange de clés hybrides post-quantiques dans Transfer Family](#pq-policy-testing)
+ [Activez l'échange de clés hybrides post-quantiques sur votre point de terminaison SFTP](#pq-enable-policy)
+ [Configurer un client SFTP qui prend en charge l'échange de clés hybrides post-quantiques](#pq-client-openssh)
+ [Confirmer l'échange de clés hybrides post-quantiques dans le SFTP](#pq-verify-exchange)
## À propos de l'échange de clés hybrides post-quantiques en SSH
Transfer Family prend en charge les suites de chiffrement hybrides post-quantiques par échange de clés, qui utilisent à la fois l'algorithme classique d'échange de clés [Elliptic Curve Diffie-Hellman (ECDH)](https://csrc.nist.gov/publications/detail/sp/800-56a/rev-3/final) et ML-KEM. ML-KEM est un algorithme de chiffrement à clé publique post-quantique et d'établissement de clés que le [National Institute for Standards and Technology (NIST)](https://csrc.nist.gov/projects/post-quantum-cryptography) a désigné comme son premier algorithme standard d'accord de clé post-quantique.
Le client et le serveur procèdent toujours à un échange de clés ECDH. De plus, le serveur encapsule un secret partagé post-quantique dans la clé publique KEM post-quantique du client, qui est annoncée dans le message d'échange de clés SSH du client. Cette stratégie combine la haute assurance d'un échange de clés classique avec la sécurité des échanges de clés post-quantiques proposés, afin de garantir la protection des poignées de main tant que l'ECDH ou le secret partagé post-quantique ne peuvent pas être brisés.
## Comment fonctionne l'établissement de clés hybrides post-quantiques dans Transfer Family
AWS a récemment annoncé la prise en charge de l'échange de clés post-quantiques dans les transferts de fichiers SFTP vers. AWS Transfer Family Transfer Family adapte en toute sécurité les transferts de business-to-business fichiers vers les services AWS de stockage à l'aide du protocole SFTP et d'autres protocoles. Le SFTP est une version plus sécurisée du protocole de transfert de fichiers (FTP) qui fonctionne via SSH. La prise en charge de l'échange de clés post-quantique de Transfer Family élève la barre de sécurité pour les transferts de données via SFTP.
Le support SFTP pour l'échange de clés hybride post-quantique dans Transfer Family inclut la combinaison des algorithmes post-quantiques ML-KEM-768 et ML-KEM-1024, avec ECDH sur des courbes P256, P384 ou Curve25519. Les méthodes d'échange de clés SSH correspondantes suivantes sont spécifiées dans [le projet d'échange de clés SSH hybride post-quantique](https://datatracker.ietf.org/doc/draft-kampanakis-curdle-ssh-pq-ke/).
+ `mlkem768nistp256-sha256`
+ `mlkem1024nistp384-sha384`
+ `mlkem768x25519-sha256`
### Pourquoi ML-KEM ?
AWS s'engage à soutenir des algorithmes standardisés et interopérables. ML-KEM est le seul algorithme d'échange de clés post-quantique standardisé et approuvé par le projet de cryptographie post-quantique du [NIST](https://csrc.nist.gov/projects/post-quantum-cryptography). Les organismes de normalisation intègrent déjà ML-KEM dans leurs protocoles. AWS prend déjà en charge ML-KEM dans TLS sur certains points de terminaison d'API. AWS
Dans le cadre de cet engagement, AWS a soumis un projet de proposition à l'IETF pour la cryptographie post-quantique qui combine ML-KEM avec des courbes approuvées par le NIST, comme P256 pour SSH. Afin d'améliorer la sécurité de nos clients, la AWS mise en œuvre de l'échange de clés post-quantique dans les protocoles SFTP et SSH fait suite à ce projet. Nous prévoyons de soutenir ses futures mises à jour jusqu'à ce que notre proposition soit adoptée par l'IETF et devienne une norme.
Les nouvelles méthodes d'échange de clés (répertoriées dans la section[Comment fonctionne l'établissement de clés hybrides post-quantiques dans Transfer Family](#pqtls-details)) pourraient changer à mesure que le projet évolue vers la normalisation.
**Note**
La prise en charge des algorithmes post-quantiques est actuellement disponible pour l'échange de clés hybrides post-quantiques dans TLS pour AWS KMS (voir [Utilisation du TLS post-quantique hybride avec AWS KMS) et les points](https://docs.aws.amazon.com/kms/latest/developerguide/pqtls.html) de terminaison d'API.AWS Certificate Manager AWS Secrets Manager
### Échange de clés SSH hybride post-quantique et exigences cryptographiques (FIPS 140)
Pour les clients qui ont besoin de se conformer à la norme FIPS, Transfer Family fournit une cryptographie SSH approuvée par FIPS en utilisant la bibliothèque cryptographique open source certifiée AWS FIPS 140, -LC. AWS Les méthodes d'échange de clés hybrides post-quantiques prises en charge dans le formulaire TransferSecurityPolicy -FIPS-2025-03 de Transfer Family sont approuvées par la FIPS [conformément à la norme SP 800-56Cr2 du NIST (section 2](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Cr2.pdf)). L'Office fédéral allemand de la sécurité de l'information ([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)) et l'Agence nationale de la sécurité des systèmes d'information ([ANSSI](https://www.ssi.gouv.fr/en/publication/anssi-views-on-the-post-quantum-cryptography-transition/)) de France recommandent également de telles méthodes d'échange de clés hybrides post-quantiques.
## Test de l'échange de clés hybrides post-quantiques dans Transfer Family
Cette section décrit les étapes à suivre pour tester l'échange de clés hybride post-quantique.
1. [Activez l'échange de clés hybrides post-quantiques sur votre point de terminaison SFTP](#pq-enable-policy).
1. Utilisez un client SFTP (tel que[Configurer un client SFTP qui prend en charge l'échange de clés hybrides post-quantiques](#pq-client-openssh)) qui prend en charge l'échange de clés hybrides post-quantiques en suivant les instructions du projet de spécification susmentionné.
1. Transférez un fichier à l'aide d'un serveur Transfer Family.
1. [Confirmer l'échange de clés hybrides post-quantiques dans le SFTP](#pq-verify-exchange).
### Activez l'échange de clés hybrides post-quantiques sur votre point de terminaison SFTP
Vous pouvez choisir la politique SSH lorsque vous créez un nouveau point de terminaison de serveur SFTP dans Transfer Family ou en modifiant les options de l'algorithme cryptographique dans un point de terminaison SFTP existant. L'instantané suivant montre un exemple de mise AWS Management Console à jour de la politique SSH.
![\[Affiche la politique post-quantique sélectionnée pour les options de l'algorithme cryptographique.\]](http://docs.aws.amazon.com/fr_fr/transfer/latest/userguide/images/post-quantum-policy-choose.png)
**Les noms de politique SSH qui prennent en charge l'échange de clés post-quantique sont **TransferSecurityPolicy-2025-03 et -FIPS-2025-03**. TransferSecurityPolicy** Pour plus de détails sur les politiques de Transfer Family, consultez[Politiques de sécurité pour les AWS Transfer Family serveurs](security-policies.md).
### Configurer un client SFTP qui prend en charge l'échange de clés hybrides post-quantiques
Après avoir sélectionné la bonne politique SSH post-quantique dans votre point de terminaison SFTP Transfer Family, vous pouvez expérimenter le SFTP post-quantique dans Transfer Family. Installez le dernier client OpenSSH (tel que la version 9.9) sur votre système local pour le tester.
**Note**
Assurez-vous que votre client prend en charge un ou plusieurs des algorithmes ML-KEM répertoriés précédemment. Vous pouvez consulter les algorithmes pris en charge pour votre version d'OpenSSH en exécutant cette commande :. `ssh -Q kex`
Vous pouvez exécuter l'exemple de client SFTP pour vous connecter à votre point de terminaison SFTP (par exemple,`s-1111aaaa2222bbbb3.server.transfer.us-west-2.amazonaws.com`) en utilisant les méthodes d'échange de clés hybrides post-quantiques, comme indiqué dans la commande suivante.
```
sftp -v -o \
KexAlgorithms=mlkem768x25519-sha256 \
-i username_private_key_PEM_file \
username@server-id.server.transfer.region-id.amazonaws.com
```
Dans la commande précédente, remplacez les éléments suivants par vos propres informations :
+ Remplacez *username\$1private\$1key\$1PEM\$1file* par le fichier codé au format PEM de la clé privée de l'utilisateur SFTP
+ Remplacez *username* par le nom d'utilisateur SFTP
+ Remplacez *server-id* par l'ID du serveur Transfer Family
+ Remplacez *region-id* par la région dans laquelle se trouve votre serveur Transfer Family
### Confirmer l'échange de clés hybrides post-quantiques dans le SFTP
Pour vérifier que l'échange de clés hybride post-quantique a été utilisé lors d'une connexion SSH entre SFTP et Transfer Family, vérifiez la sortie du client. Vous pouvez éventuellement utiliser un programme de capture de paquets. Si vous utilisez le client OpenSSH 9.9, le résultat doit ressembler à ce qui suit (en omettant les informations non pertinentes pour des raisons de concision) :
```
% 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>
```
Le résultat indique que la négociation avec le client a eu lieu à l'aide de la `mlkem768x25519-sha256` méthode hybride post-quantique et qu'une session SFTP a été établie avec succès.
# Protection et chiffrement des données
Le [modèle de responsabilité AWS partagée](https://aws.amazon.com/compliance/shared-responsibility-model/) s'applique à la protection des données dans AWS Transfer Family (Transfer Family). Comme décrit dans ce modèle, AWS est responsable de la protection de l'infrastructure mondiale qui gère l'ensemble du AWS cloud. La gestion du contrôle de votre contenu hébergé sur cette infrastructure relève de votre responsabilité. Ce contenu inclut la configuration de la sécurité et les tâches de gestion pour les AWS services que vous utilisez. Pour plus d'informations sur la confidentialité des données, veuillez consulter la [FAQ sur la confidentialité des données](https://aws.amazon.com/compliance/data-privacy-faq). Pour plus d'informations sur la protection des données en Europe, consultez le [modèle de responsabilitéAWS partagée et le billet de blog sur le RGPD](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) sur le *blog sur la AWS sécurité*.
Pour des raisons de protection des données, nous vous recommandons de protéger les informations d'identification du AWS compte et de configurer des comptes utilisateur individuels avec AWS IAM Identity Center. Ainsi, chaque utilisateur se voit attribuer uniquement les autorisations nécessaires pour exécuter ses tâches. Nous vous recommandons également de sécuriser vos données comme indiqué ci-dessous :
+ Utilisez l’authentification multifactorielle (MFA) avec chaque compte.
+ SSL/TLS À utiliser pour communiquer avec AWS les ressources. Nous prenons en charge le protocole TLS 1.2.
+ Configurez l'API et la journalisation de l'activité des utilisateurs avec AWS CloudTrail.
+ Utilisez des solutions de AWS chiffrement, ainsi que tous les contrôles de sécurité par défaut au sein AWS des services.
+ Utilisez des services de sécurité gérés avancés tels qu'Amazon Macie, qui contribuent à la découverte et à la sécurisation des données personnelles stockées dans Amazon S3.
+ Si vous avez besoin de modules cryptographiques validés FIPS 140-2 lorsque vous accédez à AWS via une CLI ou une API, utilisez un point de terminaison FIPS. Pour en savoir plus sur les points de terminaison FIPS (Federal Information Processing Standard) disponibles, veuillez consulter [Federal information processing standard (FIPS) 140-2](https://aws.amazon.com/compliance/fips/) (français non garanti).
Nous vous recommandons vivement de ne jamais placer d'informations identifiables sensibles, telles que les numéros de compte de vos clients, dans des champs de formulaire comme **Name (Nom)**. Cela inclut lorsque vous travaillez avec Transfer Family ou d'autres AWS services à l'aide de la console AWS CLI, de l'API ou AWS SDKs. Toutes les données de configuration que vous entrez dans la configuration du service Transfer Family, ou dans les configurations d'autres services, peuvent être récupérées pour être incluses dans les journaux de diagnostic. Lorsque vous fournissez une URL à un serveur externe, n’incluez pas les informations d’identification non chiffrées dans l’URL pour valider votre demande adressée au serveur.
En revanche, les données issues des opérations de chargement et de téléchargement à destination et en provenance des serveurs Transfer Family sont traitées comme totalement privées et n'existent jamais en dehors des canaux cryptés, tels qu'une connexion SFTP ou FTPS. Ces données ne sont toujours accessibles qu'aux personnes autorisées.
## Chiffrement des données dans Transfer Family
AWS Transfer Family utilise les options de chiffrement par défaut que vous avez définies pour votre compartiment Amazon S3 afin de chiffrer vos données. Lorsque vous activez le chiffrement par défaut sur un compartiment, tous les objets sont chiffrés au moment d'être stockés dans le compartiment. Les objets sont chiffrés à l'aide du chiffrement côté serveur avec des clés gérées Amazon S3 (SSE-S3) ou des clés gérées AWS Key Management Service (AWS KMS SSE-KMS). Pour plus d'informations sur le chiffrement côté serveur, consultez la section [Protection des données à l'aide du chiffrement côté serveur dans](https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html) le guide de l'utilisateur d'*Amazon Simple Storage Service*.
Les étapes suivantes vous montrent comment crypter des données. AWS Transfer Family
**Pour autoriser le chiffrement dans AWS Transfer Family**
1. Activez le chiffrement par défaut pour votre compartiment Amazon S3. Pour obtenir des instructions, consultez le [chiffrement par défaut d'Amazon S3 pour les compartiments S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-encryption.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*.
1. Mettez à jour la politique de rôle Gestion des identités et des accès AWS (IAM) attachée à l'utilisateur pour accorder les autorisations requises AWS Key Management Service (AWS KMS).
1. Si vous utilisez une stratégie de session pour l'utilisateur, celle-ci doit accorder les AWS KMS autorisations requises.
L'exemple suivant montre une politique IAM qui accorde les autorisations minimales requises lors de l'utilisation AWS Transfer Family avec un compartiment Amazon S3 activé pour le AWS KMS chiffrement. Incluez cet exemple de politique à la fois dans la stratégie de rôle IAM de l'utilisateur et dans la stratégie de session, si vous en utilisez une.
```
{
"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"
}
```
**Note**
L'ID de clé KMS que vous spécifiez dans cette politique doit être le même que celui spécifié pour le chiffrement par défaut à l'étape 1.
Le rôle root, ou le rôle IAM utilisé pour l'utilisateur, doit être autorisé dans la politique AWS KMS clé. Pour plus d'informations sur la politique AWS KMS clé, consultez la section [Utilisation des politiques clés dans AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) dans le *Guide du AWS Key Management Service développeur*.
## AWS Transfer Family chiffrement au repos
Comme il AWS Transfer Family s'agit d'un service de transfert de fichiers, il ne gère pas vos données de stockage au repos. Les services et systèmes de stockage pris AWS Transfer Family en charge sont chargés de protéger les données dans cet état. Cependant, certaines données relatives aux services sont AWS Transfer Family gérées au repos.
### Qu'est-ce qui est crypté ?
Les seules données traitées AWS Transfer Family au repos concernent les détails nécessaires au fonctionnement de vos serveurs de transfert de fichiers et au traitement des transferts. AWS Transfer Family stocke les données suivantes avec un chiffrement complet au repos dans Amazon DynamoDB :
+ Configurations du serveur (par exemple, paramètres du serveur, configurations de protocole et détails du point de terminaison).
+ Données d'authentification utilisateur, y compris les clés publiques SSH et les métadonnées utilisateur.
+ Détails de l'exécution du flux de travail et configurations des étapes.
+ Configurations du connecteur et informations d'authentification pour les systèmes tiers. Ces informations d'identification sont chiffrées à l'aide de clés de chiffrement AWS Transfer Family gérées.
#### Gestion des clés
Vous ne pouvez pas gérer les clés de chiffrement AWS Transfer Family utilisées pour stocker les informations dans DynamoDB relatives à l'exécution de vos serveurs et au traitement des transferts. Ces informations incluent les configurations de votre serveur, les données d'authentification des utilisateurs, les détails du flux de travail et les informations d'identification du connecteur.
### Qu'est-ce qui n'est pas crypté ?
Bien que AWS Transfer Family cela ne contrôle pas la manière dont vos données de stockage sont chiffrées au repos, nous vous recommandons tout de même de configurer vos emplacements de stockage avec le niveau de sécurité le plus élevé qu'ils prennent en charge. Par exemple, vous pouvez chiffrer des objets avec des clés de chiffrement gérées par Amazon S3 (SSE-S3) ou des clés ( AWS KMS SSE-KMS).
Découvrez comment les services AWS de stockage cryptent les données au repos :
+ [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)
# Gestion des clés SSH et PGP dans Transfer Family
Dans cette section, vous trouverez des informations sur les clés SSH, notamment sur la façon de les générer et de les faire pivoter. Pour en savoir plus sur l'utilisation de Transfer Family with AWS Lambda pour gérer les clés, consultez le billet de blog [Enabling user self-service key management with AWS Transfer Family and AWS Lambda](https://aws.amazon.com/blogs/storage/enabling-user-self-service-key-management-with-aws-transfer-family-and-aws-lambda/). Pour le déploiement et la gestion automatisés des utilisateurs utilisant plusieurs clés SSH, consultez[Modules Transfer Family Terraform](terraform.md).
**Note**
AWS Transfer Family accepte le RSA, l'ECDSA et les ED25519 clés pour l'authentification SSH.
Cette section explique également comment générer et gérer les clés Pretty Good Privacy (PGP).
Pour un aperçu complet de tous les algorithmes de chiffrement et de clé pris en charge, y compris des recommandations pour différents cas d'utilisation, voir[Vue d'ensemble des algorithmes de chiffrement et de clé](#encryption-algorithms-overview).
## Vue d'ensemble des algorithmes de chiffrement et de clé
AWS Transfer Family prend en charge différents types d'algorithmes à des fins différentes. Comprendre les algorithmes à utiliser pour votre cas d'utilisation spécifique permet de garantir des transferts de fichiers sécurisés et compatibles.
**Référence rapide de l'algorithme**
| Cas d’utilisation | Algorithme recommandé | Conforme à la norme FIPS | Remarques |
| --- | --- | --- | --- |
| Authentification SSH/SFTP | RSA (rsa-sha2-256/512), ECDSA ou ED25519 | RSA : Oui, ECDSA : Oui, Non ED25519 | Compatible avec tous les clients et serveurs SSH |
| Génération de clés PGP | RSA ou ECC (NIST) | Oui | Pour le déchiffrement du flux de travail |
| Chiffrement de fichiers PGP | AES-256 | Oui | Déterminé par le logiciel PGP |
## Algorithmes d'authentification SSH
Ces algorithmes sont utilisés pour SSH/SFTP l'authentification entre les clients et AWS Transfer Family les serveurs. Choisissez l'une de ces options lorsque vous générez des paires de clés SSH pour l'authentification des utilisateurs ou des clés d'hôte du serveur.
RSA (recommandé)
**Compatible avec tous les clients et serveurs SSH, et conforme à la norme FIPS.** À utiliser avec le hachage SHA-2 pour une sécurité renforcée :
+ `rsa-sha2-256`- Recommandé pour la plupart des cas d'utilisation
+ `rsa-sha2-512`- Option de sécurité accrue
ED25519
**Moderne et efficace.** Des clés de plus petite taille avec une sécurité renforcée :
+ `ssh-ed25519`- Rapide et sécurisé, mais non conforme à la norme FIPS
ECDSA
**Option de courbe elliptique.** Bon équilibre entre sécurité et performance :
+ `ecdsa-sha2-nistp256`- Courbe standard
+ `ecdsa-sha2-nistp384`- Courbe de sécurité plus élevée
+ `ecdsa-sha2-nistp521`- Courbe de sécurité la plus élevée
**Note**
Nous prenons `ssh-rsa` en charge SHA1 les anciennes politiques de sécurité. Pour en savoir plus, consultez [Algorithmes cryptographiques](security-policies.md#cryptographic-algorithms).
**Choisir le bon algorithme SSH**
+ **Pour la plupart des utilisateurs :** utilisez RSA avec ou `rsa-sha2-256` `rsa-sha2-512`
+ **Pour la conformité à la norme FIPS :** utilisez les algorithmes RSA ou ECDSA
+ **Pour les environnements modernes :** ED25519 offre une sécurité et des performances excellentes
## Algorithmes de chiffrement et de déchiffrement PGP
PGP (Pretty Good Privacy) utilise deux types d'algorithmes qui fonctionnent ensemble pour chiffrer et déchiffrer les fichiers dans les flux de travail :
1. **Algorithmes de paires de clés** : utilisés pour générer les paires de public/private clés pour le chiffrement et les signatures numériques
1. **Algorithmes symétriques** : utilisés pour chiffrer les données réelles du fichier (les algorithmes de paires de clés chiffrent la clé symétrique)
### Algorithmes de paires de clés PGP
Choisissez l'un des algorithmes suivants lorsque vous générez des paires de clés PGP pour le déchiffrement du flux de travail :
RSA (recommandé)
**Recommandé pour la plupart des utilisateurs.** Largement pris en charge, bien établi et conforme à la norme FIPS. Assure un bon équilibre entre sécurité et compatibilité.
ECC (cryptographie à courbe elliptique)
**Plus efficace que RSA** avec des clés de plus petite taille tout en garantissant une sécurité renforcée :
+ Courbes **NIST - Courbes** standard largement prises en charge et conformes à la norme FIPS
+ **BrainPool courbes - Courbes** alternatives pour des exigences de conformité spécifiques
+ **Curve25519** - Courbe moderne à hautes performances offrant une sécurité renforcée avec un calcul efficace
ElGamal
**Algorithme hérité.** Pris en charge pour la compatibilité avec les anciens systèmes. Utilisez RSA ou ECC pour les nouvelles implémentations.
Pour obtenir des instructions détaillées sur la génération de clés PGP, consultez[Génération de clés PGP](generate-pgp-keys.md).
### Algorithmes de chiffrement symétrique PGP
Ces algorithmes chiffrent les données réelles de vos fichiers. L'algorithme utilisé dépend de la façon dont le fichier PGP a été créé par votre logiciel PGP :
**Algorithmes conformes à la norme FIPS (recommandés pour les environnements réglementés)**
+ **AES-128, AES-192, AES-256** - Norme de chiffrement avancée (recommandée)
+ **3DES** - Triple Data Encryption Standard (ancienne norme, utilisez AES dans la mesure du possible)
**Autres algorithmes pris en charge**
+ IDEA, Blowfish CAST5, DES, CAMÉLIA-128, TwoFish CAMÉLIA-192, CAMÉLIA-256
**Note**
Vous ne choisissez pas directement l'algorithme symétrique lorsque vous utilisez des AWS Transfer Family flux de travail. Il est déterminé par le logiciel PGP utilisé pour créer le fichier crypté. Cependant, vous pouvez configurer votre logiciel PGP pour qu'il préfère les algorithmes conformes à la norme FIPS tels que l'AES-256.
Pour plus d'informations sur les algorithmes symétriques pris en charge, consultez[Algorithmes de chiffrement symétriques pris en charge](nominal-steps-workflow.md#symmetric-algorithms).
# Génération de clés SSH pour les utilisateurs gérés par des services
Vous pouvez configurer votre serveur pour authentifier les utilisateurs à l'aide de la méthode d'authentification gérée par le service, dans laquelle les noms d'utilisateur et les clés SSH sont stockés dans le service. La clé SSH publique de l'utilisateur est téléchargée sur le serveur en tant que propriété de l'utilisateur. Cette clé est utilisée par le serveur dans le cadre d'un processus d'authentification standard basé sur des clés. Sur un même serveur, chaque utilisateur peut disposer de plusieurs clés SSH publiques sur fichier. Pour connaître les limites du nombre de clés pouvant être stockées par utilisateur, voir les [AWS Transfer Family points de terminaison et les quotas](https://docs.aws.amazon.com//general/latest/gr/transfer-service.html) dans le *Référence générale d'Amazon Web Services*.
Comme alternative à la méthode d'authentification gérée par le service, vous pouvez authentifier les utilisateurs à l'aide d'un fournisseur d'identité personnalisé, ou AWS Directory Service for Microsoft Active Directory. Pour plus d’informations, consultez [Travailler avec des fournisseurs d'identité personnalisés](custom-idp-intro.md) ou [Utilisation de AWS Directory Service pour Microsoft Active Directory](directory-services-users.md).
Un serveur ne peut authentifier les utilisateurs qu'à l'aide d'une seule méthode (service géré, service d'annuaire ou fournisseur d'identité personnalisé), et cette méthode ne peut pas être modifiée une fois le serveur créé.
**Topics**
+ [Création de clés SSH sous macOS, Linux ou Unix](macOS-linux-unix-ssh.md)
+ [Création de clés SSH sous Microsoft Windows](windows-ssh.md)
+ [Conversion d'une SSH2 clé au format de clé publique SSH](convert-ssh2-public-key.md)
# Création de clés SSH sous macOS, Linux ou Unix
Sur les systèmes d'exploitation macOS, Linux ou Unix, vous utilisez la `ssh-keygen` commande pour créer une clé publique SSH et une clé privée SSH, également appelées paire de clés.
**Note**
Dans les exemples suivants, nous n'indiquons pas de phrase secrète : dans ce cas, l'outil vous demande de saisir votre mot de passe, puis de le répéter pour vérifier. La création d'une phrase secrète permet de mieux protéger votre clé privée et peut également améliorer la sécurité globale du système. Vous ne pouvez pas récupérer votre mot de passe : si vous l'oubliez, vous devez créer une nouvelle clé.
Toutefois, si vous générez une clé d'hôte de serveur, vous *devez* spécifier une phrase secrète vide, en spécifiant l'`-N ""`option dans la commande (ou en appuyant **Enter** deux fois lorsque vous y êtes invité), car les serveurs Transfer Family ne peuvent pas demander de mot de passe au démarrage.
**Pour créer des clés SSH sur un système d'exploitation macOS, Linux ou Unix**
1. Sur les systèmes d'exploitation macOS, Linux ou Unix, ouvrez un terminal de commande.
1. AWS Transfer Family accepte les clés au format RSA, ECDSA et ED25519 ECDSA. Choisissez la commande appropriée en fonction du type de paire de clés que vous générez.
**Conseil** : remplacez-le `key_name` par le nom réel de votre fichier de paire de clés SSH.
+ Pour générer une paire de clés RSA 4096 bits :
```
ssh-keygen -t rsa -b 4096 -f key_name
```
+ Pour générer une paire de clés ECDSA 521 bits (les tailles de bits de l'ECDSA sont de 256, 384 et 521) :
```
ssh-keygen -t ecdsa -b 521 -f key_name
```
+ Pour générer une paire de ED25519 clés :
```
ssh-keygen -t ed25519 -f key_name
```
Voici un exemple de `ssh-keygen` sortie.
```
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]-----+
```
**Conseil** : Lorsque vous exécutez la `ssh-keygen` commande comme indiqué ci-dessus, elle crée les clés publiques et privées sous forme de fichiers dans le répertoire en cours.
Votre paire de clés SSH est maintenant prête à être utilisée. Suivez les étapes 3 et 4 pour stocker la clé publique SSH pour les utilisateurs gérés par le service. Ces utilisateurs utilisent les clés lorsqu'ils transfèrent des fichiers sur les terminaux du serveur Transfer Family.
1. Accédez au `key_name.pub` fichier et ouvrez-le.
1. Copiez le texte et collez-le dans la **clé publique SSH pour l'utilisateur** géré par le service.
1. Ouvrez la AWS Transfer Family console sur [https://console.aws.amazon.com/transfer/](https://console.aws.amazon.com/transfer/), puis sélectionnez **Serveurs** dans le volet de navigation.
1. Sur la page **Serveurs**, sélectionnez l'**ID** du serveur qui contient l'utilisateur que vous souhaitez mettre à jour.
1. Sélectionnez l'utilisateur pour lequel vous ajoutez une clé publique.
1. Dans le volet **Clés publiques SSH**, choisissez **Ajouter une clé publique SSH**.
![\[La AWS Transfer Family console, qui affiche les détails de l'utilisateur sélectionné.\]](http://docs.aws.amazon.com/fr_fr/transfer/latest/userguide/images/edit-user-add-key-01.png)
1. Collez le texte de la clé publique que vous avez générée dans la zone de texte de la clé publique SSH, puis choisissez **Ajouter une clé**.
![\[La AWS Transfer Family console, qui affiche la page Ajouter une clé pour ajouter une clé publique.\]](http://docs.aws.amazon.com/fr_fr/transfer/latest/userguide/images/edit-user-add-key-02.png)
La nouvelle clé est répertoriée dans le volet des clés publiques SSH.
![\[La AWS Transfer Family console, qui affiche la clé publique récemment ajoutée dans la section Clés publiques SSH.\]](http://docs.aws.amazon.com/fr_fr/transfer/latest/userguide/images/edit-user-add-key-03.png)
# Création de clés SSH sous Microsoft Windows
Windows inclut OpenSSH en tant que fonctionnalité intégrée, que vous pouvez utiliser pour générer des clés SSH dans le même format que sous Linux ou macOS. Vous pouvez également utiliser des outils tiers tels que le générateur de clés de PuTTY (PuTTYgen).
## Utilisation de l'OpenSSH intégré à Windows
Les versions récentes de Windows incluent OpenSSH par défaut. Vous pouvez utiliser les mêmes `ssh-keygen` commandes que celles décrites dans la section macOS/Linux :
1. Ouvrez Windows PowerShell ou une invite de commande.
1. Exécutez l'une des commandes suivantes en fonction du type de clé que vous souhaitez générer :
+ Pour générer une paire de clés RSA 4096 bits :
```
ssh-keygen -t rsa -b 4096 -f key_name
```
+ Pour générer une paire de clés ECDSA 521 bits :
```
ssh-keygen -t ecdsa -b 521 -f key_name
```
+ Pour générer une paire de ED25519 clés :
```
ssh-keygen -t ed25519 -f key_name
```
1. Suivez les mêmes étapes que dans la macOS/Linux section pour télécharger votre clé publique sur AWS Transfer Family.
## Utilisation de Pu TTYgen (outil tiers)
Certains clients SSH tiers pour Windows, tels que PuTTY, utilisent différents formats de clés. PuTTY utilise le `PPK` format des clés privées. Si vous utilisez PuTTY ou des outils connexes tels que WinSCP, vous pouvez utiliser Pu TTYgen pour créer des clés dans ce format.
**Note**
Si vous présentez à WinSCP un fichier de clé privée non formaté, ce client propose de convertir la clé `.ppk` `.ppk` en format pour vous.
Pour un didacticiel sur la création de clés SSH à l'aide de PuTTYgen, consultez le site Web [SSH.com](https://www.ssh.com/ssh/putty/windows/puttygen).
# Conversion d'une SSH2 clé au format de clé publique SSH
AWS Transfer Family accepte uniquement les clés publiques au format SSH. Si vous avez une clé SSH2 publique, vous devez la convertir. Le format d'une clé SSH2 publique est le suivant :
```
---- BEGIN SSH2 PUBLIC KEY ----
Comment: "rsa-key-20160402"
AAAAB3NzaC1yc2EAAAABJQAAAgEAiL0jjDdFqK/kYThqKt7THrjABTPWvXmB3URI
:
:
---- END SSH2 PUBLIC KEY ----
```
Le format d'une clé publique SSH est le suivant :
```
ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAA...
```
Exécutez la commande suivante pour convertir une clé publique au SSH2 format SSH en clé publique au format SSH. *ssh2-key*Remplacez-le par le nom de votre SSH2 clé et *ssh-key* par le nom de votre clé SSH.
```
ssh-keygen -i -f ssh2-key.pub > ssh-key.pub
```
# Faire pivoter les clés SSH
Pour des raisons de sécurité, nous recommandons la meilleure pratique qui consiste à faire pivoter vos clés SSH. Généralement, cette rotation est spécifiée dans le cadre d'une politique de sécurité et est mise en œuvre de manière automatisée. Selon le niveau de sécurité, pour une communication très sensible, une paire de clés SSH peut être utilisée une seule fois. Cela élimine les risques liés au stockage des clés. Cependant, il est beaucoup plus courant de stocker les informations d'identification SSH pendant un certain temps et de définir un intervalle qui n'impose pas une charge excessive aux utilisateurs. Cette période est souvent de trois mois.
**Note**
Pour une rotation automatique des clés SSH utilisant l'infrastructure comme code, voir[Modules Transfer Family Terraform](terraform.md).
Il existe deux méthodes de rotation de clés SSH :
+ Sur la console, vous pouvez télécharger une nouvelle clé publique SSH et supprimer une clé publique SSH existante.
+ À l'aide de l'API, vous pouvez mettre à jour les utilisateurs existants en utilisant l'[DeleteSshPublicKey](https://docs.aws.amazon.com//transfer/latest/APIReference/API_DeleteSshPublicKey.html)API pour supprimer la clé publique Secure Shell (SSH) d'un utilisateur et l'[ImportSshPublicKey](https://docs.aws.amazon.com/transfer/latest/APIReference/API_ImportSshPublicKey.html)API pour ajouter une nouvelle clé publique Secure Shell (SSH) au compte de l'utilisateur.
------
#### [ Console ]
**Pour effectuer une rotation des touches dans la console**
1. Ouvrez la AWS Transfer Family console à l'adresse [https://console.aws.amazon.com/transfer/](https://console.aws.amazon.com/transfer/).
1. Accédez à la page **Serveurs**.
1. Choisissez l'identifiant dans la colonne **ID du serveur** pour afficher la page de **détails du serveur**.
1. Sous **Utilisateurs**, cochez la case de l'utilisateur dont vous souhaitez faire pivoter la clé publique SSH, puis choisissez **Actions**, puis choisissez **Ajouter une clé** pour afficher la page **Ajouter une clé**.
or
Choisissez le nom d'**utilisateur pour voir la page des détails** de l'utilisateur, puis choisissez **Ajouter une clé publique SSH** pour afficher la page **Ajouter une clé**.
1. Entrez la nouvelle clé publique SSH et choisissez **Ajouter une clé**.
**Important**
Le format de la clé publique SSH dépend du type de clé que vous avez générée.
Pour les clés RSA, le format est`ssh-rsa string`.
Pour ED25519 les clés, le format est`ssh-ed25519 string`.
Pour les clés ECDSA, la clé commence par`ecdsa-sha2-nistp256`, ou `ecdsa-sha2-nistp384``ecdsa-sha2-nistp521`, selon la taille de la clé que vous avez générée. La chaîne de début est ensuite suivie de`string`, comme pour les autres types de clés.
Vous êtes renvoyé à la page des **détails de l'utilisateur**, et la nouvelle clé publique SSH que vous venez de saisir apparaît dans la section **Clés publiques SSH**.
1. Cochez la case correspondant à l'ancienne touche YOU que vous souhaitez supprimer, puis choisissez **Supprimer**.
1. Confirmez l'opération de suppression en saisissant le mot`delete`, puis choisissez **Supprimer**.
------
#### [ API ]
**Pour effectuer une rotation des clés à l'aide de l'API**
1. Sur les systèmes d'exploitation macOS, Linux ou Unix, ouvrez un terminal de commande.
1. Récupérez la clé SSH que vous souhaitez supprimer en saisissant la commande suivante. Pour utiliser cette commande, remplacez-la `serverID` par l'ID de serveur de votre serveur Transfer Family, puis par `username` votre nom d'utilisateur.
```
aws transfer describe-user --server-id='serverID' --user-name='username'
```
La commande renvoie des informations sur l'utilisateur. Copiez le contenu du `"SshPublicKeyId":` champ. Vous devrez saisir cette valeur ultérieurement au cours de cette procédure.
```
"SshPublicKeys": [ { "SshPublicKeyBody": "public-key", "SshPublicKeyId": "keyID",
"DateImported": 1621969331.072 } ],
```
1. Importez ensuite une nouvelle clé SSH pour votre utilisateur. À l'invite , entrez la commande suivante. Pour utiliser cette commande, `serverID` remplacez-la par l'ID du serveur de votre serveur Transfer Family, `username` par votre nom d'utilisateur et `public-key` par l'empreinte digitale de votre nouvelle clé publique.
```
aws transfer import-ssh-public-key --server-id='serverID' --user-name='username'
--ssh-public-key-body='public-key'
```
``Si la commande aboutit, aucune sortie n'est renvoyée.
1. Enfin, supprimez l'ancienne clé en exécutant la commande suivante. Pour utiliser cette commande, remplacez `serverID` par l'ID de serveur de votre serveur Transfer Family, remplacez par `username` votre nom d'utilisateur et remplacez par la valeur `keyID-from-step-2` d'ID clé que vous avez copiée à l'étape 2 de cette procédure
```
aws transfer delete-ssh-public-key --server-id='serverID' --user-name='username'
--ssh-public-key-id='keyID-from-step-2'
```
1. (Facultatif) Pour confirmer que l'ancienne clé n'existe plus, répétez l'étape 2.
------
# Génération de clés PGP
Vous pouvez utiliser le décryptage Pretty Good Privacy (PGP) avec les fichiers que Transfer Family traite avec des flux de travail. Pour utiliser le déchiffrement dans une étape du flux de travail, fournissez une clé PGP. Pour des informations détaillées sur les algorithmes clés PGP, y compris les recommandations et la conformité à la norme FIPS, consultez. [Algorithmes de paires de clés PGP](key-management.md#pgp-key-algorithms)
Le blog sur le AWS stockage contient un article qui décrit comment simplement déchiffrer des fichiers sans écrire de code à l'aide des flux de travail Transfer Family Managed, [crypter et déchiffrer des fichiers avec](https://aws.amazon.com/blogs/storage/encrypt-and-decrypt-files-with-pgp-and-aws-transfer-family/) PGP et. AWS Transfer Family
L'opérateur que vous utilisez pour générer vos clés PGP dépend de votre système d'exploitation et de la version du logiciel de génération de clés que vous utilisez.
Si vous utilisez Linux ou Unix, utilisez le programme d'installation de votre package pour l'installer`gpg`. En fonction de votre distribution Linux, l'une des commandes suivantes devrait fonctionner pour vous.
```
sudo yum install gnupg
```
```
sudo apt-get install gnupg
```
Pour Windows ou macOS, vous pouvez télécharger ce dont vous avez besoin [sur https://gnupg.org/download/](https://gnupg.org/download/).
Après avoir installé votre logiciel de génération de clés PGP, vous devez exécuter la `gpg --gen-key` commande `gpg --full-gen-key` or pour générer une paire de clés.
**Note**
Si vous utilisez la `GnuPG` version 2.3.0 ou une version plus récente, vous devez exécuter`gpg --full-gen-key`. Lorsque vous êtes invité à saisir le type de clé à créer, choisissez RSA ou ECC. Si vous choisissez **ECC**, vous pouvez choisir entre NIST BrainPool et Curve25519 pour la courbe elliptique.
**`gpg`Sous-commandes utiles**
Voici quelques sous-commandes utiles pour `gpg` :
+ `gpg --help`— Cette commande répertorie les options disponibles et peut inclure quelques exemples.
+ `gpg --list-keys`— Cette commande répertorie les détails de toutes les paires de clés que vous avez créées.
+ `gpg --fingerprint`— Cette commande répertorie les détails de toutes vos paires de clés, y compris l'empreinte digitale de chaque clé.
+ `gpg --export -a user-name`— Cette commande exporte la partie clé publique de la `user-name` clé utilisée lors de la génération de la clé.
# Gérer les clés PGP
Pour gérer vos clés PGP, utilisez AWS Secrets Manager.
**Note**
Votre nom secret inclut votre identifiant de serveur Transfer Family. Cela signifie que vous devez déjà avoir identifié ou créé un serveur *avant* de pouvoir y stocker les informations de votre clé PGP. AWS Secrets Manager
Si vous souhaitez utiliser une seule clé et une seule phrase secrète pour tous vos utilisateurs, vous pouvez enregistrer les informations du bloc de clés PGP sous le nom secret`aws/transfer/server-id/@pgp-default`, où se `server-id` trouve l'identifiant de votre serveur Transfer Family. Transfer Family utilise cette clé par défaut si aucune clé ne `user-name` correspond à l'utilisateur qui exécute le flux de travail.
Vous pouvez créer une clé pour un utilisateur spécifique. Dans ce cas, le format du nom du secret est `aws/transfer/server-id/user-name` le suivant : où `user-name` correspond à l'utilisateur qui exécute le flux de travail pour un serveur Transfer Family.
**Note**
Vous pouvez stocker un maximum de 3 clés privées PGP, par serveur Transfer Family, par utilisateur.
**Pour configurer les clés PGP à utiliser avec le déchiffrement**
1. Selon la version de GPG que vous utilisez, exécutez l'une des commandes suivantes pour générer une paire de clés PGP.
+ Si vous utilisez la **GnuPG** version 2.3.0 ou une version plus récente, exécutez la commande suivante :
```
gpg --full-gen-key
```
Vous pouvez choisir**RSA**, ou, si vous le souhaitez**ECC**, vous pouvez choisir l'une ou l'autre**NIST**, **BrainPool** ou **Curve25519** pour la courbe elliptique. Si vous exécutez `gpg --gen-key` plutôt, vous créez une paire de clés qui utilise l'algorithme de chiffrement ECC Curve 25519.
+ Pour les versions **GnuPG** antérieures à 2.3.0, vous pouvez utiliser la commande suivante, car RSA est le type de chiffrement par défaut.
```
gpg --gen-key
```
**Important**
Pendant le processus de génération des clés, vous devez fournir un mot de passe et une adresse e-mail. Assurez-vous de prendre note de ces valeurs. Vous devez fournir le mot de passe lorsque vous entrez les détails de la clé AWS Secrets Manager plus loin dans cette procédure. Et vous devez fournir la même adresse e-mail pour exporter la clé privée à l'étape suivante.
1. Exécutez la commande suivante pour exporter la clé privée. Pour utiliser cette commande, `private.pgp` remplacez-la par le nom du fichier dans lequel vous souhaitez enregistrer le bloc de clé privée et `marymajor@example.com` par l'adresse e-mail que vous avez utilisée lors de la génération de la paire de clés.
```
gpg --output private.pgp --armor --export-secret-key marymajor@example.com
```
1. AWS Secrets Manager Utilisez-le pour stocker votre clé PGP.
1. Connectez-vous à la AWS Secrets Manager console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Dans le panneau de navigation de gauche, choisissez **Secrets**.
1. Sur la page **Secrets**, choisissez **Enregistrer un nouveau secret**.
1. Sur la page **Choisir un type de secret**, pour **Type de secret**, sélectionnez **Autre type de secret**.
1. Dans la section **Paires clé/valeur**, choisissez l'onglet **clé/valeur**.
+ **Clé** — Entrée**PGPPrivateKey**.
**Note**
Vous devez saisir la **PGPPrivateKey** chaîne exactement : n'ajoutez aucun espace avant ou entre les caractères.
+ **valeur** — Collez le texte de votre clé privée dans le champ de valeur. Le texte de votre clé privée se trouve dans le fichier (par exemple`private.pgp`) que vous avez spécifié lors de l'exportation de votre clé au début de cette procédure. La clé commence par `-----BEGIN PGP PRIVATE KEY BLOCK-----` et se termine par`-----END PGP PRIVATE KEY BLOCK-----`.
**Note**
Assurez-vous que le bloc de texte contient uniquement la clé privée et ne contient pas également la clé publique.
1. Sélectionnez **Ajouter une ligne** et dans la section **Paires clé/valeur**, choisissez l'onglet **clé/valeur**.
+ **Clé** — Entrée**PGPPassphrase**.
**Note**
Vous devez saisir la **PGPPassphrase** chaîne exactement : n'ajoutez aucun espace avant ou entre les caractères.
+ **valeur** — Entrez le mot de passe que vous avez utilisé lorsque vous avez généré votre paire de clés PGP.
![\[\]](http://docs.aws.amazon.com/fr_fr/transfer/latest/userguide/images/pgp-secrets-01.png)
**Note**
Vous pouvez ajouter jusqu'à 3 jeux de clés et de phrases de passe. Pour ajouter un deuxième ensemble, ajoutez deux nouvelles lignes, entrez **PGPPrivateKey2** et **PGPPassphrase2** pour les clés, puis collez une autre clé privée et une autre phrase secrète. Pour ajouter un troisième ensemble, les valeurs clés doivent être **PGPPrivateKey3** et**PGPPassphrase3**.
1. Choisissez **Suivant**.
1. Sur la page **Configurer le secret**, entrez le nom et la description de votre secret.
+ Si vous créez une clé par défaut, c'est-à-dire une clé qui peut être utilisée par n'importe quel utilisateur de Transfer Family, entrez**aws/transfer/*server-id*/@pgp-default**. Remplacez `server-id` par l'ID du serveur qui contient le flux de travail comportant une étape de déchiffrement.
+ Si vous créez une clé destinée à être utilisée par un utilisateur spécifique de Transfer Family, entrez**aws/transfer/*server-id*/*user-name***. Remplacez `server-id` par l'ID du serveur qui contient le flux de travail comportant une étape de déchiffrement et remplacez `user-name` par le nom de l'utilisateur qui exécute le flux de travail. `user-name`Il est stocké dans le fournisseur d'identité utilisé par le serveur Transfer Family.
1. Choisissez **Next** et acceptez les valeurs par défaut sur la page **Configurer la rotation**. Ensuite, sélectionnez **Suivant**.
1. Sur la page **Révision**, choisissez **Store** pour créer et stocker le secret.
La capture d'écran suivante montre les informations relatives à l'utilisateur **marymajor** pour un serveur Transfer Family spécifique. Cet exemple montre trois clés et les phrases de passe correspondantes.
![\[\]](http://docs.aws.amazon.com/fr_fr/transfer/latest/userguide/images/pgp-secrets-02.png)
# Clients PGP pris en charge
Les clients suivants ont été testés avec Transfer Family et peuvent être utilisés pour générer des clés PGP et pour chiffrer des fichiers que vous souhaitez déchiffrer à l'aide d'un flux de travail.
+ **GPG4win** \$1 Cléopâtre.
**Note**
Lorsque vous sélectionnez **Signer/Chiffrer des fichiers**, assurez-vous de désactiver la sélection pour **Signer en tant que** : nous ne prenons actuellement pas en charge la signature pour les fichiers chiffrés.
![\[\]](http://docs.aws.amazon.com/fr_fr/transfer/latest/userguide/images/workflows-step-decrypt-kleopatra.png)
Si vous signez le fichier chiffré et tentez de le télécharger sur un serveur Transfer Family avec un flux de déchiffrement, le message d'erreur suivant s'affiche :
```
Encrypted file with signed message unsupported
```
+ Principales versions de **GnuPG** : 2.4, 2.3, 2.2, 2.0 et 1.4.
Notez que d'autres clients PGP peuvent également fonctionner, mais seuls les clients mentionnés ici ont été testés avec Transfer Family.
# Gestion des identités et des accès pour AWS Transfer Family
Gestion des identités et des accès AWS (IAM) est un outil Service AWS qui permet à un administrateur de contrôler en toute sécurité l'accès aux AWS ressources. Les administrateurs IAM contrôlent qui peut être *authentifié* (connecté) et *autorisé (autorisé*) à utiliser AWS Transfer Family les ressources. IAM est un Service AWS outil que vous pouvez utiliser sans frais supplémentaires.
**Topics**
+ [Public ciblé](#security_iam_audience)
+ [Authentification par des identités](#security_iam_authentication)
+ [Gestion de l’accès à l’aide de politiques](#security_iam_access-manage)
+ [Comment AWS Transfer Family fonctionne avec IAM](security_iam_service-with-iam.md)
+ [AWS Transfer Family exemples de politiques basées sur l'identité](security_iam_id-based-policy-examples.md)
+ [AWS Transfer Family exemples de politiques basées sur des balises](security_iam_tag-based-policy-examples.md)
+ [Résolution des problèmes AWS Transfer Family d'identité et d'accès](security_iam_troubleshoot.md)
+ [Clés de condition IAM pour la gouvernance organisationnelle](transfer-condition-keys.md)
## Public ciblé
La façon dont vous utilisez Gestion des identités et des accès AWS (IAM) varie en fonction de votre rôle :
+ **Utilisateur du service** : demandez des autorisations à votre administrateur si vous ne pouvez pas accéder aux fonctionnalités (voir [Résolution des problèmes AWS Transfer Family d'identité et d'accès](security_iam_troubleshoot.md))
+ **Administrateur du service** : déterminez l’accès des utilisateurs et soumettez les demandes d’autorisation (voir [Comment AWS Transfer Family fonctionne avec IAM](security_iam_service-with-iam.md))
+ **Administrateur IAM** : rédigez des politiques pour gérer l’accès (voir [AWS Transfer Family exemples de politiques basées sur l'identité](security_iam_id-based-policy-examples.md))
## Authentification par des identités
L'authentification est la façon dont vous vous connectez à AWS l'aide de vos informations d'identification. Vous devez être authentifié en tant qu'utilisateur IAM ou en assumant un rôle IAM. Utilisateur racine d'un compte AWS
Vous pouvez vous connecter en tant qu'identité fédérée à l'aide d'informations d'identification provenant d'une source d'identité telle que AWS IAM Identity Center (IAM Identity Center), d'une authentification unique ou d'informations d'identification. Google/Facebook Pour plus d’informations sur la connexion, consultez [Connexion à votre Compte AWS](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) dans le *Guide de l’utilisateur Connexion à AWS *.
Pour l'accès par programmation, AWS fournit un SDK et une CLI pour signer les demandes de manière cryptographique. Pour plus d’informations, consultez [Signature AWS Version 4 pour les demandes d’API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) dans le *Guide de l’utilisateur IAM*.
### Utilisateur racine d'un compte AWS
Lorsque vous créez un Compte AWS, vous commencez par une seule identité de connexion appelée *utilisateur Compte AWS root* qui dispose d'un accès complet à toutes Services AWS les ressources. Il est vivement déconseillé d’utiliser l’utilisateur racine pour vos tâches quotidiennes. Pour les tâches qui requièrent des informations d’identification de l’utilisateur racine, consultez [Tâches qui requièrent les informations d’identification de l’utilisateur racine](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks) dans le *Guide de l’utilisateur IAM*.
### Identité fédérée
Il est recommandé d'obliger les utilisateurs humains à utiliser la fédération avec un fournisseur d'identité pour accéder à Services AWS l'aide d'informations d'identification temporaires.
Une *identité fédérée* est un utilisateur provenant de l'annuaire de votre entreprise, de votre fournisseur d'identité Web ou Directory Service qui y accède à Services AWS l'aide d'informations d'identification provenant d'une source d'identité. Les identités fédérées assument des rôles qui fournissent des informations d’identification temporaires.
Pour une gestion des accès centralisée, nous vous recommandons d’utiliser AWS IAM Identity Center. Pour plus d’informations, consultez [Qu’est-ce que IAM Identity Center ?](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
### Utilisateurs et groupes IAM
Un *[utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)* est une identité qui dispose d’autorisations spécifiques pour une seule personne ou application. Nous vous recommandons d’utiliser ces informations d’identification temporaires au lieu des utilisateurs IAM avec des informations d’identification à long terme. Pour plus d'informations, voir [Exiger des utilisateurs humains qu'ils utilisent la fédération avec un fournisseur d'identité pour accéder à AWS l'aide d'informations d'identification temporaires](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) dans le *guide de l'utilisateur IAM*.
[https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) spécifient une collection d’utilisateurs IAM et permettent de gérer plus facilement les autorisations pour de grands ensembles d’utilisateurs. Pour plus d’informations, consultez [Cas d’utilisation pour les utilisateurs IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html) dans le *Guide de l’utilisateur IAM*.
### Rôles IAM
Un *[rôle IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* est une identité dotée d’autorisations spécifiques qui fournit des informations d’identification temporaires. Vous pouvez assumer un rôle en [passant d'un rôle d'utilisateur à un rôle IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html) ou en appelant une opération d' AWS API AWS CLI ou d'API. Pour plus d’informations, consultez [Méthodes pour endosser un rôle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage-assume.html) dans le *Guide de l’utilisateur IAM*.
Les rôles IAM sont utiles pour l’accès des utilisateurs fédérés, les autorisations temporaires des utilisateurs IAM, les accès intercompte, les accès entre services et les applications exécutées sur Amazon EC2. Pour plus d’informations, consultez [Accès intercompte aux ressources dans IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) dans le *Guide de l’utilisateur IAM*.
## Gestion de l’accès à l’aide de politiques
Vous contrôlez l'accès en AWS créant des politiques et en les associant à AWS des identités ou à des ressources. Une politique définit les autorisations lorsqu'elles sont associées à une identité ou à une ressource. AWS évalue ces politiques lorsqu'un directeur fait une demande. La plupart des politiques sont stockées AWS sous forme de documents JSON. Pour plus d’informations les documents de politique JSON, consultez [Vue d’ensemble des politiques JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json) dans le *Guide de l’utilisateur IAM*.
À l’aide de politiques, les administrateurs précisent qui a accès à quoi en définissant quel **principal** peut effectuer des **actions** sur quelles **ressources** et dans quelles **conditions**.
Par défaut, les utilisateurs et les rôles ne disposent d’aucune autorisation. Un administrateur IAM crée des politiques IAM et les ajoute aux rôles, que les utilisateurs peuvent ensuite assumer. Les politiques IAM définissent les autorisations quelle que soit la méthode que vous utilisez pour exécuter l’opération.
### Politiques basées sur l’identité
Les stratégies basées sur l’identité sont des documents de stratégie d’autorisations JSON que vous attachez à une identité (utilisateur, groupe ou rôle). Ces politiques contrôlent les actions que peuvent exécuter ces identités, sur quelles ressources et dans quelles conditions. Pour découvrir comment créer une politique basée sur l’identité, consultez [Définition d’autorisations IAM personnalisées avec des politiques gérées par le client](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) dans le *Guide de l’utilisateur IAM*.
Les politiques basées sur l’identité peuvent être des *politiques intégrées* (intégrées directement dans une seule identité) ou des *politiques gérées (politiques* autonomes associées à plusieurs identités). Pour découvrir comment choisir entre des politiques gérées et en ligne, consultez [Choix entre les politiques gérées et les politiques en ligne](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-choosing-managed-or-inline.html) dans le *Guide de l’utilisateur IAM*.
### Politiques basées sur les ressources
Les politiques basées sur les ressources sont des documents de politique JSON que vous attachez à une ressource. Les exemples incluent *les politiques de confiance de rôle* IAM et les *stratégies de compartiment* Amazon S3. Dans les services qui sont compatibles avec les politiques basées sur les ressources, les administrateurs de service peuvent les utiliser pour contrôler l’accès à une ressource spécifique. Vous devez [spécifier un principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html) dans une politique basée sur les ressources.
Les politiques basées sur les ressources sont des politiques en ligne situées dans ce service. Vous ne pouvez pas utiliser les politiques AWS gérées par IAM dans une stratégie basée sur les ressources.
### Listes de contrôle d'accès (ACLs)
Les listes de contrôle d'accès (ACLs) contrôlent les principaux (membres du compte, utilisateurs ou rôles) autorisés à accéder à une ressource. ACLs sont similaires aux politiques basées sur les ressources, bien qu'elles n'utilisent pas le format de document de politique JSON.
Amazon S3 et AWS WAF Amazon VPC sont des exemples de services compatibles. ACLs Pour en savoir plus ACLs, consultez la [présentation de la liste de contrôle d'accès (ACL)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html) dans le *guide du développeur Amazon Simple Storage Service*.
### Autres types de politique
AWS prend en charge des types de politiques supplémentaires qui peuvent définir les autorisations maximales accordées par les types de politiques les plus courants :
+ **Limites d’autorisations** : une limite des autorisations définit le nombre maximum d’autorisations qu’une politique basée sur l’identité peut accorder à une entité IAM. Pour plus d’informations, consultez [Limites d’autorisations pour des entités IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html) dans le *Guide de l’utilisateur IAM*.
+ **Politiques de contrôle des services (SCPs)** — Spécifiez les autorisations maximales pour une organisation ou une unité organisationnelle dans AWS Organizations. Pour plus d’informations, consultez [Politiques de contrôle de service](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) dans le *Guide de l’utilisateur AWS Organizations *.
+ **Politiques de contrôle des ressources (RCPs)** : définissez le maximum d'autorisations disponibles pour les ressources de vos comptes. Pour plus d'informations, voir [Politiques de contrôle des ressources (RCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html) dans le *guide de AWS Organizations l'utilisateur*.
+ **Politiques de session** : politiques avancées que vous passez en tant que paramètre lorsque vous créez par programmation une session temporaire pour un rôle ou un utilisateur fédéré. Pour plus d’informations, consultez [Politiques de session](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session) dans le *Guide de l’utilisateur IAM*.
### Plusieurs types de politique
Lorsque plusieurs types de politiques s’appliquent à la requête, les autorisations en résultant sont plus compliquées à comprendre. Pour savoir comment AWS déterminer s'il faut autoriser une demande lorsque plusieurs types de politiques sont impliqués, consultez la section [Logique d'évaluation des politiques](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html) dans le *guide de l'utilisateur IAM*.
# Comment AWS Transfer Family fonctionne avec IAM
Avant d'utiliser Gestion des identités et des accès AWS (IAM) pour gérer l'accès à AWS Transfer Family, vous devez connaître les fonctionnalités IAM disponibles. AWS Transfer Family Pour obtenir une vue d'ensemble de la façon dont AWS Transfer Family les autres AWS services fonctionnent avec IAM, consultez la section [AWS Services compatibles avec IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) dans le Guide de l'utilisateur d'*IAM*.
**Topics**
+ [AWS Transfer Family politiques basées sur l'identité](#security_iam_service-with-iam-id-based-policies)
+ [AWS Transfer Family politiques basées sur les ressources](#security_iam_service-with-iam-resource-based-policies)
+ [Autorisation basée sur les AWS Transfer Family tags](#security_iam_service-with-iam-tags)
+ [AWS Transfer Family Rôles IAM](#security_iam_service-with-iam-roles)
## AWS Transfer Family politiques basées sur l'identité
Avec les politiques basées sur l'identité IAM, vous pouvez spécifier des actions et ressources autorisées ou refusées, ainsi que les conditions dans lesquelles les actions sont autorisées ou refusées. AWS Transfer Family prend en charge des actions, ressources et clés de condition spécifiques. Pour en savoir plus sur tous les éléments que vous utilisez dans une politique JSON, consultez la [référence des éléments de stratégie JSON IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) dans le *guide de l'Gestion des identités et des accès AWS utilisateur*.
### Actions
Les administrateurs peuvent utiliser les politiques AWS JSON pour spécifier qui a accès à quoi. C’est-à-dire, quel **principal** peut effectuer **des actions** sur quelles **ressources** et dans quelles **conditions**.
L’élément `Action` d’une politique JSON décrit les actions que vous pouvez utiliser pour autoriser ou refuser l’accès à une politique. Intégration d’actions dans une politique afin d’accorder l’autorisation d’exécuter les opérations associées.
Les actions de politique en AWS Transfer Family cours utilisent le préfixe suivant avant l'action :`transfer:`. Par exemple, pour autoriser quelqu'un à créer un serveur, vous devez inclure l'`transfer:CreateServer`action dans sa politique à l'aide de l'opération d'`CreateServer`API Transfer Family. Les déclarations de politique doivent inclure un élément `Action` ou `NotAction`. AWS Transfer Family définit son propre ensemble d’actions qui décrivent les tâches que vous pouvez effectuer avec ce service.
Pour spécifier plusieurs actions dans une seule instruction, séparez-les par des virgules, comme suit :
```
"Action": [
"transfer:action1",
"transfer:action2"
```
Vous pouvez aussi préciser plusieurs actions à l’aide de caractères génériques (\$1). Par exemple, pour spécifier toutes les actions qui commencent par le mot `Describe`, incluez l’action suivante.
```
"Action": "transfer:Describe*"
```
Pour consulter la liste des AWS Transfer Family actions, reportez-vous à la section [Actions définies par AWS Transfer Family](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awstransferfamily.html#awstransferfamily-actions-as-permissions) dans la *référence d'autorisation de service*.
### Ressources
Les administrateurs peuvent utiliser les politiques AWS JSON pour spécifier qui a accès à quoi. C’est-à-dire, quel **principal** peut effectuer **des actions** sur quelles **ressources** et dans quelles **conditions**.
L’élément de politique JSON `Resource` indique le ou les objets auxquels l’action s’applique. Il est recommandé de définir une ressource à l’aide de son [Amazon Resource Name (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html). Pour les actions qui ne sont pas compatibles avec les autorisations de niveau ressource, utilisez un caractère générique (\$1) afin d’indiquer que l’instruction s’applique à toutes les ressources.
```
"Resource": "*"
```
La ressource du serveur Transfer Family possède l'ARN suivant.
```
arn:aws:transfer:${Region}:${Account}:server/${ServerId}
```
Par exemple, pour spécifier le serveur `s-01234567890abcdef` Transfer Family dans votre relevé, utilisez l'ARN suivant.
```
"Resource": "arn:aws:transfer:us-east-1:123456789012:server/s-01234567890abcdef"
```
Pour plus d'informations sur le format de ARNs, consultez [Amazon Resource Names (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) dans le *Service Authorization Reference* ou [IAM ARNs](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-arns) dans le guide de l'*utilisateur IAM*.
Pour spécifier toutes les instances qui appartiennent à un compte spécifique, utilisez le caractère générique (\$1).
```
"Resource": "arn:aws:transfer:us-east-1:123456789012:server/*"
```
Certaines AWS Transfer Family actions sont effectuées sur plusieurs ressources, telles que celles utilisées dans les politiques IAM. Dans ces cas-là, vous devez utiliser le caractère générique (\$1).
```
"Resource": "arn:aws:transfer:*:123456789012:server/*"
```
Dans certains cas, vous devez spécifier plusieurs types de ressources, par exemple si vous créez une politique qui autorise l'accès aux serveurs et aux utilisateurs de Transfer Family. Pour spécifier plusieurs ressources dans une seule instruction, séparez-les ARNs par des virgules.
```
"Resource": [
"resource1",
"resource2"
]
```
Pour consulter la liste des AWS Transfer Family ressources, consultez la section [Types de ressources définis par AWS Transfer Family](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awstransferfamily.html#awstransferfamily-resources-for-iam-policies) dans la *référence d'autorisation de service*.
### Clés de condition
Les administrateurs peuvent utiliser les politiques AWS JSON pour spécifier qui a accès à quoi. C’est-à-dire, quel **principal** peut effectuer **des actions** sur quelles **ressources** et dans quelles **conditions**.
L’élément `Condition` indique à quel moment les instructions s’exécutent en fonction de critères définis. Vous pouvez créer des expressions conditionnelles qui utilisent des [opérateurs de condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), tels que les signes égal ou inférieur à, pour faire correspondre la condition de la politique aux valeurs de la demande. Pour voir toutes les clés de condition AWS globales, voir les clés de [contexte de condition AWS globales](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) dans le *guide de l'utilisateur IAM*.
AWS Transfer Family définit son propre ensemble de clés de condition et prend également en charge l'utilisation de certaines clés de condition globales. Pour consulter la liste des clés de AWS Transfer Family condition, reportez-vous à la section [Clés de condition pour AWS Transfer Family](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awstransferfamily.html#awstransferfamily-policy-keys) la *référence d'autorisation de service*.
### Exemples
Pour consulter des exemples de politiques AWS Transfer Family basées sur l'identité, consultez. [AWS Transfer Family exemples de politiques basées sur l'identité](security_iam_id-based-policy-examples.md) Pour les politiques IAM spécifiques aux points de terminaison VPC, consultez. [Limiter l'accès aux points de terminaison VPC pour les serveurs Transfer Family](create-server-in-vpc.md#limit-vpc-endpoint-access)
## AWS Transfer Family politiques basées sur les ressources
Les politiques basées sur les ressources sont des documents de politique JSON qui spécifient les actions qu'un principal spécifié peut effectuer sur la AWS Transfer Family ressource et dans quelles conditions. Amazon S3 prend en charge les politiques d'autorisation basées sur les ressources pour Amazon S3. *buckets* Les politiques basées sur les ressources permettent d'accorder une autorisation à d'autres comptes en fonction des ressources. Vous pouvez également utiliser une politique basée sur les ressources pour autoriser un AWS service à accéder à votre Amazon S3. *buckets*
Pour permettre un accès comptes multiples , vous pouvez spécifier un compte entier ou des entités IAM dans un autre compte en tant que [principal dans une stratégie basée sur les ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html). L’ajout d’un principal intercompte à une politique basée sur les ressources ne représente qu’une partie de l’instauration de la relation d’approbation. Lorsque le principal et la ressource se trouvent dans des AWS comptes différents, vous devez également accorder à l'entité principale l'autorisation d'accéder à la ressource. Accordez l'autorisation en attachant une stratégie basée sur les identités à l'entité. Toutefois, si une stratégie basée sur des ressources accorde l'accès à un principal dans le même compte, aucune autre stratégie basée sur l'identité n'est requise. *Pour plus d'informations, consultez la section En [quoi les rôles IAM diffèrent des politiques basées sur les ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html) dans le Guide de l'Gestion des identités et des accès AWS utilisateur.*
Le service Amazon S3 ne prend en charge qu'un seul type de politique basée sur les ressources, appelée **bucket*stratégie*, qui est attachée à un. *bucket* Cette politique définit les entités principales (comptes, utilisateurs, rôles et utilisateurs fédérés) qui peuvent effectuer des actions sur l'objet.
### Exemples
Pour consulter des exemples de politiques AWS Transfer Family basées sur les ressources, consultez. [AWS Transfer Family exemples de politiques basées sur des balises](security_iam_tag-based-policy-examples.md)
## Autorisation basée sur les AWS Transfer Family tags
Vous pouvez associer des balises aux AWS Transfer Family ressources ou transmettre des balises dans une demande à AWS Transfer Family. Pour contrôler l’accès basé sur des étiquettes, vous devez fournir les informations d’étiquette dans l’[élément de condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) d’une politique utilisant les clés de condition `transfer:ResourceTag/key-name`, `aws:RequestTag/key-name` ou `aws:TagKeys`. Pour plus d'informations sur l'utilisation des balises pour contrôler l'accès aux AWS Transfer Family ressources, consultez[AWS Transfer Family exemples de politiques basées sur des balises](security_iam_tag-based-policy-examples.md).
## AWS Transfer Family Rôles IAM
Un [rôle IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) est une entité de votre AWS compte qui possède des autorisations spécifiques.
### Utilisation d'informations d'identification temporaires avec AWS Transfer Family
Vous pouvez utiliser des informations d’identification temporaires pour vous connecter à l’aide de la fédération, endosser un rôle IAM ou encore pour endosser un rôle intercompte. Vous obtenez des informations d'identification de sécurité temporaires en appelant des opérations d' AWS STS API telles que [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 prend en charge l'utilisation d'informations d'identification temporaires.
# AWS Transfer Family exemples de politiques basées sur l'identité
Par défaut, les utilisateurs et les rôles IAM ne sont pas autorisés à créer ou modifier les ressources AWS Transfer Family . Ils ne peuvent pas non plus effectuer de tâches à l'aide de l' AWS API AWS Management Console AWS CLI, ou. Un administrateur IAM doit créer des politiques IAM autorisant les utilisateurs et les rôles à exécuter des opérations d'API spécifiques sur les ressources spécifiées dont ils ont besoin. Il doit ensuite attacher ces politiques aux utilisateurs ou aux groupes IAM ayant besoin de ces autorisations.
*Pour savoir comment créer une politique basée sur l'identité IAM à l'aide de ces exemples de documents de politique JSON, consultez la section [Création de politiques dans l'onglet JSON du guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) de l'Gestion des identités et des accès AWS utilisateur.*
**Topics**
+ [Bonnes pratiques en matière de politiques](#security_iam_service-with-iam-policy-best-practices)
+ [Utilisation de la AWS Transfer Family console](#security_iam_id-based-policy-examples-console)
+ [Autorisation accordée aux utilisateurs pour afficher leurs propres autorisations](#security_iam_id-based-policy-examples-view-own-permissions)
## Bonnes pratiques en matière de politiques
Les politiques basées sur l'identité déterminent si quelqu'un peut créer, accéder ou supprimer AWS Transfer Family des ressources dans votre compte. Ces actions peuvent entraîner des frais pour votre Compte AWS. Lorsque vous créez ou modifiez des politiques basées sur l’identité, suivez ces instructions et recommandations :
+ **Commencez AWS par les politiques gérées et passez aux autorisations du moindre privilège : pour commencer à accorder des autorisations** à vos utilisateurs et à vos charges de travail, utilisez les *politiques AWS gérées* qui accordent des autorisations pour de nombreux cas d'utilisation courants. Ils sont disponibles dans votre Compte AWS. Nous vous recommandons de réduire davantage les autorisations en définissant des politiques gérées par les AWS clients spécifiques à vos cas d'utilisation. Pour plus d’informations, consultez [politiques gérées par AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) ou [politiques gérées par AWS pour les activités professionnelles](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) dans le *Guide de l’utilisateur IAM*.
+ **Accordez les autorisations de moindre privilège** : lorsque vous définissez des autorisations avec des politiques IAM, accordez uniquement les autorisations nécessaires à l’exécution d’une seule tâche. Pour ce faire, vous définissez les actions qui peuvent être entreprises sur des ressources spécifiques dans des conditions spécifiques, également appelées *autorisations de moindre privilège*. Pour plus d’informations sur l’utilisation d’IAM pour appliquer des autorisations, consultez [politiques et autorisations dans IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) dans le *Guide de l’utilisateur IAM*.
+ **Utilisez des conditions dans les politiques IAM pour restreindre davantage l’accès** : vous pouvez ajouter une condition à vos politiques afin de limiter l’accès aux actions et aux ressources. Par exemple, vous pouvez écrire une condition de politique pour spécifier que toutes les demandes doivent être envoyées via SSL. Vous pouvez également utiliser des conditions pour accorder l'accès aux actions de service si elles sont utilisées par le biais d'un service spécifique Service AWS, tel que CloudFormation. Pour plus d’informations, consultez [Conditions pour éléments de politique JSON IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) dans le *Guide de l’utilisateur IAM*.
+ **Utilisez l’Analyseur d’accès IAM pour valider vos politiques IAM afin de garantir des autorisations sécurisées et fonctionnelles** : l’Analyseur d’accès IAM valide les politiques nouvelles et existantes de manière à ce que les politiques IAM respectent le langage de politique IAM (JSON) et les bonnes pratiques IAM. IAM Access Analyzer fournit plus de 100 vérifications de politiques et des recommandations exploitables pour vous aider à créer des politiques sécurisées et fonctionnelles. Pour plus d’informations, consultez [Validation de politiques avec IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) dans le *Guide de l’utilisateur IAM*.
+ **Exiger l'authentification multifactorielle (MFA**) : si vous avez un scénario qui nécessite des utilisateurs IAM ou un utilisateur root, activez l'authentification MFA pour une sécurité accrue. Compte AWS Pour exiger la MFA lorsque des opérations d’API sont appelées, ajoutez des conditions MFA à vos politiques. Pour plus d’informations, consultez [Sécurisation de l’accès aux API avec MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) dans le *Guide de l’utilisateur IAM*.
Pour plus d’informations sur les bonnes pratiques dans IAM, consultez [Bonnes pratiques de sécurité dans IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) dans le *Guide de l’utilisateur IAM*.
## Utilisation de la AWS Transfer Family console
Pour accéder à la AWS Transfer Family console, vous devez disposer d'un ensemble minimal d'autorisations. Ces autorisations doivent vous permettre de répertorier et d'afficher les informations relatives AWS Transfer Family aux ressources de votre AWS compte. Si vous créez une politique basée sur l'identité qui est plus restrictive que les autorisations minimales requises, la console ne fonctionnera pas comme prévu pour les entités (utilisateurs et rôles IAM) tributaires de cette politique. Pour plus d'informations, consultez la section [Ajouter des autorisations à un utilisateur](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) dans le *Guide de Gestion des identités et des accès AWS l'utilisateur*.
Il n'est pas nécessaire d'accorder des autorisations de console minimales aux utilisateurs qui appellent uniquement l'API AWS CLI ou l' AWS API. Autorisez plutôt l’accès à uniquement aux actions qui correspondent à l’opération d’API que vous tentez d’effectuer.
## Autorisation accordée aux utilisateurs pour afficher leurs propres autorisations
Cet exemple montre comment créer une politique qui permet aux utilisateurs IAM d’afficher les politiques en ligne et gérées attachées à leur identité d’utilisateur. Cette politique inclut les autorisations permettant d'effectuer cette action sur la console ou par programmation à l'aide de l'API AWS CLI or 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 exemples de politiques basées sur des balises
Vous trouverez ci-dessous des exemples de contrôle de l'accès aux AWS Transfer Family ressources à l'aide de balises.
## Utilisation de balises pour contrôler l'accès aux AWS Transfer Family ressources
Les conditions des politiques IAM font partie de la syntaxe que vous utilisez pour spécifier les autorisations relatives aux AWS Transfer Family ressources. Vous pouvez contrôler l'accès aux AWS Transfer Family ressources (telles que les utilisateurs, les serveurs, les rôles et autres entités) en fonction des balises associées à ces ressources. Les balises sont des paires clé-valeur. Pour plus d'informations sur le balisage des ressources, consultez la section [Marquage AWS des ressources](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) dans le. *Références générales AWS*
Dans AWS Transfer Family, les ressources peuvent avoir des balises, et certaines actions peuvent inclure des balises. Lorsque vous créez une stratégie IAM, vous pouvez utiliser des clés de condition de balise pour contrôler les éléments suivants :
+ Quels utilisateurs peuvent effectuer des actions sur une AWS Transfer Family ressource, en fonction des balises que possède la ressource.
+ quelles balises peuvent être transmises dans une demande d'action ;
+ si des clés de balise spécifiques peuvent être utilisées dans une demande.
En utilisant le contrôle d'accès basé sur des balises, vous pouvez appliquer un contrôle plus fin qu'au niveau de l'API. Vous pouvez également appliquer un contrôle plus dynamique qu'en utilisant le contrôle d'accès basé sur les ressources. Vous pouvez créer des politiques IAM qui autorisent ou refusent une opération en fonction des balises fournies dans la demande (balises de demande). Vous pouvez également créer des politiques IAM basées sur les balises de la ressource utilisée (balises de ressource). En général, les balises de ressources concernent les balises déjà présentes sur les ressources, tandis que les balises de requête sont destinées à être utilisées lorsque vous ajoutez des balises à une ressource ou que vous en supprimez.
Pour connaître la syntaxe et la sémantique complètes des clés de condition des balises, consultez la section [Contrôle de l'accès aux AWS ressources à l'aide des balises de ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) dans le guide de l'utilisateur *IAM*. Pour plus de détails sur la spécification des politiques IAM avec API Gateway, consultez la section [Contrôler l'accès à une API avec des autorisations IAM](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) dans le guide du *développeur d'API Gateway*.
### Exemple 1 : Refuser les actions en fonction des balises de ressources
Vous pouvez refuser l'exécution d'une action sur une ressource en fonction de balises. L'exemple de politique suivant refuse`TagResource`,`UntagResource`,`StartServer`, `StopServer``DescribeServer`, et les `DescribeUser` opérations si la ressource utilisateur ou serveur est étiquetée avec la clé `stage` et la valeur`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"
}
}
}
]
}
```
### Exemple 2 : Autoriser les actions en fonction des balises de ressources
Vous pouvez autoriser l'exécution d'une action sur une ressource en fonction de balises. L'exemple de politique suivant autorise les `DescribeUser` opérations `TagResource` `UntagResource``StartServer`,`StopServer`,`DescribeServer`,, et si la ressource utilisateur ou serveur est étiquetée avec la clé `stage` et la valeur`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"
}
}
}
]
}
```
### Exemple 3 : Refuser la création d'un utilisateur ou d'un serveur en fonction des balises de requête
L'exemple de politique suivant contient deux déclarations. La première instruction refuse l'`CreateServer`opération sur toutes les ressources si la clé du centre de coûts associée à la balise n'a pas de valeur.
La deuxième instruction refuse l'`CreateServer`opération si la clé du centre de coûts pour la balise contient une valeur autre que 1, 2 ou 3.
**Note**
Cette politique permet de créer ou de supprimer une ressource contenant une clé appelée `costcenter` et une valeur 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"
]
}
}
}
]
}
```
# Résolution des problèmes AWS Transfer Family d'identité et d'accès
Utilisez les informations suivantes pour vous aider à diagnostiquer et à résoudre les problèmes courants que vous pouvez rencontrer lorsque vous travaillez avec AWS Transfer Family IAM.
**Topics**
+ [Je ne suis pas autorisé à effectuer une action dans AWS Transfer Family](#security_iam_troubleshoot-no-permissions)
+ [Je ne suis pas autorisé à effectuer iam : PassRole](#security_iam_troubleshoot-passrole)
+ [Je souhaite autoriser des personnes extérieures à mon AWS compte à accéder à mes AWS Transfer Family ressources](#security_iam_troubleshoot-cross-account-access)
## Je ne suis pas autorisé à effectuer une action dans AWS Transfer Family
S'il vous AWS Management Console indique que vous n'êtes pas autorisé à effectuer une action, vous devez contacter votre administrateur pour obtenir de l'aide. Votre administrateur est la personne qui vous a fourni vos informations de connexion.
L'exemple d'erreur suivant se produit lorsque l'utilisateur IAM `mateojackson` tente d'utiliser la console pour afficher des informations détaillées concernant un élément *widget* mais ne dispose pas des autorisations `transfer:GetWidget` nécessaires.
```
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: transfer:GetWidget on resource: my-example-widget
```
Dans ce cas, Mateo demande à son administrateur de mettre à jour ses politiques pour lui permettre d’accéder à la ressource `my-example-widget` à l’aide de l’action `transfer;:GetWidget`.
## Je ne suis pas autorisé à effectuer iam : PassRole
Si vous recevez une erreur selon laquelle vous n’êtes pas autorisé à exécuter `iam:PassRole` l’action, vos stratégies doivent être mises à jour afin de vous permettre de transmettre un rôle à AWS Transfer Family.
Certains vous Services AWS permettent de transmettre un rôle existant à ce service au lieu de créer un nouveau rôle de service ou un rôle lié à un service. Pour ce faire, vous devez disposer des autorisations nécessaires pour transmettre le rôle au service.
L’exemple d’erreur suivant se produit lorsqu’un utilisateur IAM nommé `marymajor` essaie d’utiliser la console pour exécuter une action dans AWS Transfer Family. Toutefois, l'action nécessite que le service ait des autorisations accordées par une fonction de service. Mary n'est pas autorisée à transmettre le rôle au service.
```
User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole
```
Dans ce cas, les politiques de Mary doivent être mises à jour pour lui permettre d’exécuter l’action `iam:PassRole`.
Si vous avez besoin d'aide, contactez votre AWS administrateur. Votre administrateur vous a fourni vos informations d’identification de connexion.
L'exemple de politique suivant contient l'autorisation de transmettre un rôle à AWS Transfer Family. **123456789012**Remplacez-le par votre identifiant de compte AWS et **MyTransferRole** par le nom de votre rôle IAM réel.
****
```
{
"Version":"2012-10-17",
"Statement": [
{ "Action": "iam:PassRole",
"Resource": "arn:aws:iam::123456789012:role/MyTransferRole",
"Effect": "Allow"
}
]
}
```
## Je souhaite autoriser des personnes extérieures à mon AWS compte à accéder à mes AWS Transfer Family ressources
Vous pouvez créer un rôle que les utilisateurs provenant d’autres comptes ou les personnes extérieures à votre organisation pourront utiliser pour accéder à vos ressources. Vous pouvez spécifier qui est autorisé à assumer le rôle. Pour les services qui prennent en charge les politiques basées sur les ressources ou les listes de contrôle d'accès (ACLs), vous pouvez utiliser ces politiques pour autoriser les utilisateurs à accéder à vos ressources.
Pour plus d’informations, consultez les éléments suivants :
+ Pour savoir si ces fonctionnalités sont prises AWS Transfer Family en charge, consultez[Comment AWS Transfer Family fonctionne avec IAM](security_iam_service-with-iam.md).
+ Pour savoir comment fournir l'accès à vos ressources sur celles Comptes AWS que vous possédez, consultez la section [Fournir l'accès à un utilisateur IAM dans un autre utilisateur Compte AWS que vous possédez](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html) dans le Guide de l'*utilisateur IAM*.
+ Pour savoir comment fournir l'accès à vos ressources à des tiers Comptes AWS, consultez la section [Fournir un accès à des ressources Comptes AWS détenues par des tiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html) dans le *guide de l'utilisateur IAM*.
+ Pour savoir comment fournir un accès par le biais de la fédération d’identité, consultez [Fournir un accès à des utilisateurs authentifiés en externe (fédération d’identité)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html) dans le *Guide de l’utilisateur IAM*.
+ Pour en savoir plus sur la différence entre l’utilisation des rôles et des politiques basées sur les ressources pour l’accès intercompte, consultez [Accès intercompte aux ressources dans IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) dans le *Guide de l’utilisateur IAM*.
# Clés de condition IAM pour la gouvernance organisationnelle
AWS Transfer Family fournit des clés de condition IAM qui vous permettent de restreindre les configurations de ressources dans n'importe quelle politique IAM. Ces clés de condition peuvent être utilisées dans des politiques basées sur l'identité associées à des utilisateurs ou à des rôles, ou dans des politiques de contrôle des services (SCPs) pour la gouvernance organisationnelle.
Les politiques de contrôle des services sont des politiques IAM qui s'appliquent à AWS l'ensemble d'une organisation et fournissent des garanties préventives sur plusieurs comptes. Lorsqu'elles sont utilisées SCPs, ces clés de condition aident à appliquer les exigences de sécurité et de conformité à l'échelle de l'organisation.
**Voir aussi**
+ [Actions, ressources et clés de condition pour Transfer Family](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awstransferfamily.html)
+ [Politiques de contrôle des services (SCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html)
+ Vidéo expliquant comment appliquer des garde-fous préventifs à l'aide de politiques de contrôle des services
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/mEO05mmbSms)
## Clés de condition disponibles
AWS Transfer Family prend en charge les clés de condition suivantes à utiliser dans les politiques IAM :
`transfer:RequestServerEndpointType`
Limite la création et les mises à jour de serveurs en fonction du type de point de terminaison (PUBLIC, VPC, VPC\$1ENDPOINT). Couramment utilisé pour empêcher les terminaux destinés au public.
`transfer:RequestServerProtocols`
Limite la création et les mises à jour de serveurs en fonction des protocoles pris en charge (SFTP, FTPS, FTP,). AS2
`transfer:RequestServerDomain`
Limite la création de serveurs en fonction du type de domaine (S3, EFS).
`transfer:RequestConnectorProtocol`
Limite la création de connecteurs en fonction du protocole (AS2SFTP).
## Actions prises en charge
Les clés de condition peuvent être appliquées aux AWS Transfer Family actions suivantes :
+ `CreateServer`: Supports `RequestServerEndpointType` `RequestServerProtocols` et clés de `RequestServerDomain` condition
+ `UpdateServer`: Supports `RequestServerEndpointType` et clés de `RequestServerProtocols` condition
+ `CreateConnector`: Supporte la clé de `RequestConnectorProtocol` condition
## Exemple de politique SCP
L'exemple de SCP suivant empêche la création de AWS Transfer Family serveurs publics au sein de votre organisation :
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "DenyPublicTransferServers",
"Effect": "Deny",
"Action": ["transfer:CreateServer", "transfer:UpdateServer"],
"Resource": "*",
"Condition": {
"StringEquals": {
"transfer:RequestServerEndpointType": "PUBLIC"
}
}
}]
}
```
# Validation de conformité pour AWS Transfer Family
Des auditeurs tiers évaluent la sécurité et AWS Transfer Family la conformité de plusieurs programmes de AWS conformité. Il s'agit notamment des certifications SOC, PCI, HIPAA. Pour la liste complète, voir [AWS Services concernés par programme de conformité](https://aws.amazon.com/compliance/services-in-scope).
Pour une liste des AWS services concernés par des programmes de conformité spécifiques, voir [AWS Services concernés par programme de conformité](https://aws.amazon.com/compliance/services-in-scope/). Pour obtenir des informations générales, veuillez consulter [Programmes de conformité d’AWS](https://aws.amazon.com/compliance/programs/).
Vous pouvez télécharger des rapports d'audit tiers à l'aide de AWS Artifact. Pour plus d'informations, consultez la section [Téléchargement de rapports dans AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html).
Votre responsabilité en matière de conformité lors de l'utilisation AWS Transfer Family est déterminée par la sensibilité de vos données, les objectifs de conformité de votre entreprise et les lois et réglementations applicables. AWS fournit les ressources suivantes pour faciliter la mise en conformité :
+ [Guides de démarrage rapide sur la sécurité et la conformité](https://aws.amazon.com/quickstart/?awsf.quickstart-homepage-filter=categories%23security-identity-compliance) : ces guides de déploiement abordent les considérations architecturales et indiquent les étapes à suivre pour déployer des environnements de base axés sur la sécurité et la conformité sur. AWS
+ Livre blanc [sur l'architecture pour la sécurité et la conformité HIPAA — Ce livre blanc](https://docs.aws.amazon.com/whitepapers/latest/architecting-hipaa-security-and-compliance-on-aws/introduction.html) décrit comment les entreprises peuvent créer des applications conformes à la loi HIPAA. AWS
+ [Ressources de conformité d’AWS](https://aws.amazon.com/compliance/resources/) – Cet ensemble de manuels et de guides peut s’appliquer à votre secteur et à votre emplacement.
+ [AWS Config](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html)— Ce AWS service évalue dans quelle mesure les configurations de vos ressources sont conformes aux pratiques internes, aux directives du secteur et aux réglementations.
+ [AWS Security Hub CSPM](https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html)— Ce AWS service fournit une vue complète de l'état de votre sécurité interne, AWS ce qui vous permet de vérifier votre conformité aux normes et aux meilleures pratiques du secteur de la sécurité.
# Résilience dans AWS Transfer Family
L'infrastructure AWS mondiale est construite autour des AWS régions et des zones de disponibilité. AWS Les régions fournissent plusieurs zones de disponibilité physiquement séparées et isolées, connectées par un réseau à faible latence, à haut débit et hautement redondant. Avec les zones de disponibilité, vous pouvez concevoir et exploiter des applications et des bases de données qui basculent automatiquement d’une zone de disponibilité à l’autre sans interruption. Les zones de disponibilité sont plus hautement disponibles, tolérantes aux pannes et évolutives que les infrastructures traditionnelles à un ou plusieurs centres de données.
AWS Transfer Family prend en charge jusqu'à 3 zones de disponibilité et s'appuie sur un parc redondant à évolutivité automatique pour vos demandes de connexion et de transfert.
Pour tous les points de terminaison Transfer Family :
+ La redondance au niveau de la zone de disponibilité est intégrée au service.
+ Il existe des flottes redondantes pour chaque AZ.
+ Cette redondance est fournie automatiquement.
**Note**
Pour les points de terminaison d'un Virtual Private Cloud (VPC), il est possible de fournir un sous-réseau unique. Toutefois, nous vous recommandons de créer des points de terminaison dans plusieurs zones de disponibilité au sein de votre VPC, afin de réduire le risque d'interruptions de service en cas de panne de zone de disponibilité.
**Voir aussi**
+ Pour plus de détails sur la création de serveurs Transfer Family dans un VPC, consultez. [Création d'un serveur dans un cloud privé virtuel](create-server-in-vpc.md)
+ Pour plus d'informations sur les zones de disponibilité Régions AWS et les zones de disponibilité, consultez la section [Infrastructure AWS globale](https://aws.amazon.com/about-aws/global-infrastructure/).
+ Pour un exemple sur la manière de renforcer la redondance et de minimiser la latence du réseau en utilisant le routage basé sur la latence, consultez le billet de blog [Minimisez la latence du réseau](https://aws.amazon.com/blogs/storage/minimize-network-latency-with-your-aws-transfer-for-sftp-servers/) avec vos serveurs. AWS Transfer Family
# Créez une connexion privée entre un VPC et AWS Transfer Family APIs
Vous pouvez établir une connexion privée entre votre VPC et en AWS Transfer Family APIs créant un point de *terminaison VPC* d'interface, alimenté par. [AWS PrivateLink](https://aws.amazon.com/privatelink/) Vous pouvez y accéder AWS Transfer Family APIs comme s'il se trouvait dans votre VPC, sans utiliser de passerelle Internet, de périphérique NAT, de connexion VPN ou de connexion Direct AWS Connect. Les instances de votre VPC ne nécessitent pas d'adresses IP publiques pour communiquer avec AWS Transfer Family APIs.
Nous créons une interface réseau de point de terminaison dans chaque sous-réseau que vous activez pour le point de terminaison d’interface. Pour plus d'informations, consultez la section [Accès aux AWS services AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/privatelink-access-aws-services.html) dans le *AWS PrivateLink Guide*. *Avant de configurer un point de terminaison VPC d'interface pour AWS Transfer Family APIs, consultez les [considérations](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#considerations-interface-endpoints) du AWS PrivateLink guide.*
## Contrôle de l'accès à l'aide des politiques de point de terminaison VPC
Par défaut, l'accès complet à AWS Transfer Family APIs est autorisé via le point de terminaison. Vous pouvez contrôler l'accès au point de terminaison de l'interface à l'aide des politiques de point de terminaison VPC. Vous pouvez attacher une stratégie de point de terminaison à votre point de terminaison d’un VPC qui contrôle l’accès à AWS Transfer Family APIs. La politique spécifie les informations suivantes :
+ Le **principal** qui peut effectuer des actions.
+ Les **actions** qui peuvent être effectuées.
+ Les **ressources** sur lesquelles les actions peuvent être effectuées.
Pour plus d’informations, consultez [Contrôle de l’accès aux services avec points de terminaison d’un VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) dans le *Guide de l’utilisateur Amazon VPC*.
Voici un exemple de politique de point de terminaison pour AWS Transfer Family APIs. Lorsqu'elle est attachée à un point de terminaison, cette politique donne accès à toutes les AWS Transfer Family APIs actions sur toutes les ressources, à l'exception de celles qui sont étiquetées avec une clé `Environment` et une valeur`Test`.
```
{
"Statement": [{
"Effect": "Deny",
"Action": "transfer:StartFileTransfer",
"Principal": "*",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Environment": "Test"
}
}
}, {
"Effect": "Allow",
"Action": "transfer:*",
"Principal": "*",
"Resource": "*"
}]
}
```
## Créez un point de terminaison VPC d'interface pour AWS Transfer Family APIs
Vous pouvez créer un point de terminaison VPC pour AWS Transfer Family APIs utiliser la console Amazon VPC ou l'interface de ligne de AWS commande ().AWS CLI Pour plus d’informations, consultez [Créer un point de terminaison d’un VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) dans le *Guide AWS PrivateLink*.
Créez un point de terminaison VPC pour AWS Transfer Family APIs utiliser l'un des noms de service suivants :
+ `com.amazonaws.region.transfer`
+ `com.amazonaws.region.transfer-fips`— Pour créer un point de terminaison VPC d'interface conforme à la publication 140-3 du Federal Information Processing Standard (FIPS), norme gouvernementale américaine.
Si vous activez le DNS privé pour le point de terminaison, vous pouvez faire des demandes d’API à AWS Transfer Family APIs en utilisant son nom DNS par défaut pour la région, par exemple `transfer.us-east-1.amazonaws.com`.
# Sécurité de l'infrastructure dans AWS Transfer Family
En tant que service géré, AWS Transfer Family il est protégé par la sécurité du réseau AWS mondial. Pour plus d'informations sur les services AWS de sécurité et sur la manière dont AWS l'infrastructure est protégée, consultez la section [Sécurité du AWS cloud](https://aws.amazon.com/security/). Pour concevoir votre AWS environnement en utilisant les meilleures pratiques en matière de sécurité de l'infrastructure, consultez la section [Protection de l'infrastructure](https://docs.aws.amazon.com/wellarchitected/latest/security-pillar/infrastructure-protection.html) dans le cadre * AWS bien architecturé du pilier de sécurité*.
Vous utilisez des appels d'API AWS publiés pour accéder AWS Transfer Family via le réseau. Les clients doivent prendre en charge les éléments suivants :
+ Protocole TLS (Transport Layer Security). Nous exigeons TLS 1.2 et recommandons TLS 1.3.
+ Ses suites de chiffrement PFS (Perfect Forward Secrecy) comme DHE (Ephemeral Diffie-Hellman) ou ECDHE (Elliptic Curve Ephemeral Diffie-Hellman). La plupart des systèmes modernes tels que Java 7 et les versions ultérieures prennent en charge ces modes.
## Évitez de placer NLBs les AWS Transfer Family serveurs et NATs de les placer devant eux
**Note**
Les serveurs configurés avec les protocoles FTP et FTPS autorisent uniquement une configuration avec un VPC : aucun point de terminaison public n'est disponible pour FTP/FTPS.
De nombreux clients configurent un Network Load Balancer (NLB) pour acheminer le trafic vers leur serveur. AWS Transfer Family Ils le font généralement soit parce qu'ils ont créé leur AWS serveur avant de pouvoir y accéder depuis leur VPC et depuis Internet, soit pour prendre en charge le protocole FTP sur Internet. Cette configuration augmente non seulement les coûts pour les clients, mais peut également entraîner d'autres problèmes, décrits dans cette section.
Les passerelles NAT sont un composant obligatoire lorsque les clients se connectent à partir d'un réseau privé protégé par un pare-feu d'entreprise. Sachez toutefois que lorsque de nombreux clients se trouvent derrière la même passerelle NAT, cela peut avoir un impact sur les performances et les limites de connexion. S'il existe un NLB ou un NAT dans le chemin de communication entre le client et le serveur FTP ou FTPS, le serveur ne peut pas reconnaître avec précision l'adresse IP du client, car AWS Transfer Family il ne voit que l'adresse IP du NLB ou du NAT.
Si vous utilisez la configuration d'un serveur Transfer Family derrière un NLB, nous vous recommandons de passer à un point de terminaison VPC et d'utiliser une adresse IP Elastic au lieu d'utiliser un NLB. Lorsque vous utilisez des passerelles NAT, tenez compte des limites de connexion décrites ci-dessous.
Si vous utilisez le protocole FTPS, cette configuration réduit non seulement votre capacité à vérifier qui accède à votre serveur, mais elle peut également avoir un impact sur les performances. AWS Transfer Family utilise l'adresse IP source pour partager vos connexions sur notre plan de données. Pour le FTPS, cela signifie qu'au lieu d'avoir 10 000 connexions simultanées, les serveurs Transfer Family avec des passerelles NLB ou NAT sur la route de communication sont limités à seulement 300 connexions simultanées.
Bien que nous vous recommandions d'éviter les équilibreurs de charge réseau placés devant AWS Transfer Family les serveurs, si votre implémentation FTP ou FTPS nécessite un NLB ou un NAT dans la route de communication en provenance du client, suivez les recommandations suivantes :
+ Pour un NLB, utilisez le port 21 pour les contrôles de santé, au lieu des ports 8192-8200.
+ Pour le AWS Transfer Family serveur, activez la reprise de session TLS en `TlsSessionResumptionMode = ENFORCED` configurant.
**Note**
Il s'agit du mode recommandé, car il offre une sécurité renforcée :
Exige que les clients utilisent la reprise de session TLS pour les connexions suivantes.
Fournit des garanties de sécurité renforcées en garantissant des paramètres de chiffrement cohérents.
Aide à prévenir les attaques de rétrogradation potentielles.
Maintient la conformité aux normes de sécurité tout en optimisant les performances.
+ Si possible, évitez d'utiliser un NLB pour tirer pleinement parti des limites de AWS Transfer Family performances et de connexion.
Pour obtenir des conseils supplémentaires sur les alternatives NLB, contactez l'équipe de gestion des AWS Transfer Family produits via le AWS Support. Pour plus d'informations sur l'amélioration de votre niveau de sécurité, consultez le billet de blog [Six conseils pour améliorer la sécurité de votre AWS Transfer Family serveur](https://aws.amazon.com/blogs/security/six-tips-to-improve-the-security-of-your-aws-transfer-family-server/).
## Sécurité de l'infrastructure de connectivité VPC
Les connecteurs SFTP avec sortie VPC améliorent la sécurité de l'infrastructure grâce à l'isolation du réseau et à la connectivité privée :
### Avantages de l'isolation du réseau
+ **Trafic réseau privé** : tout le trafic du connecteur vers les serveurs SFTP privés reste dans votre VPC et ne transite jamais par l'Internet public.
+ **Sortie contrôlée : pour les points de terminaison publics accessibles via VPC, le trafic passe par vos passerelles NAT, ce qui vous permet de contrôler les adresses** IP de sortie et les politiques réseau.
+ **Contrôles de sécurité VPC** : exploitez les groupes de sécurité, le réseau et les tables de routage VPC existants pour contrôler l'accès au réseau ACLs des connecteurs.
+ **Connectivité hybride** : accédez aux serveurs SFTP sur site via des connexions VPN ou Direct Connect établies sans exposition supplémentaire à Internet.
### Considérations de sécurité relatives à Resource Gateway
Les passerelles de ressources fournissent des points d'entrée sécurisés pour l'accès aux ressources entre VPC :
+ **Déploiement multi-AZ** : les passerelles de ressources nécessitent des sous-réseaux situés dans au moins deux zones de disponibilité pour garantir une haute disponibilité et une tolérance aux pannes.
+ **Contrôles des groupes** de sécurité : configurez les groupes de sécurité pour restreindre l'accès aux ports SFTP (généralement le port 22) aux seules sources autorisées.
+ **Emplacement des sous-réseaux privés** : déployez des passerelles de ressources dans des sous-réseaux privés lors de la connexion à des serveurs SFTP privés afin de maintenir l'isolation du réseau.
+ **Limites de connexion** : chaque passerelle de ressources prend en charge jusqu'à 350 connexions simultanées avec un délai d'inactivité de 350 secondes pour les connexions TCP.
# Ajouter un pare-feu pour applications Web
AWS WAF est un pare-feu pour applications Web qui aide à protéger les applications Web APIs contre les attaques. Vous pouvez l'utiliser pour configurer un ensemble de règles connu sous le nom de *liste de contrôle d'accès Web* (ACL Web) qui autorise, bloque ou compte les requêtes Web en fonction de règles et de conditions de sécurité Web personnalisables que vous définissez. Pour plus d'informations, consultez la section [Utilisation AWS WAF pour protéger votre APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-aws-waf.html).
**Pour ajouter AWS WAF**
1. Ouvrez la console API Gateway à l'adresse [https://console.aws.amazon.com/apigateway/](https://console.aws.amazon.com/apigateway/).
1. Dans le volet **APIs**de navigation, puis choisissez votre modèle de fournisseur d'identité personnalisé.
1. Choisissez **Stages (Étapes)**.
1. Dans le volet **Stages**, choisissez le nom de l'étape.
1. Dans le volet **Stage Editor**, sélectionnez l'onglet **Settings**.
1. Effectuez l’une des actions suivantes :
+ Sous **Web Application Firewall (WAF)**, pour **Web ACL**, choisissez l'ACL Web que vous souhaitez associer à cette étape.
+ Si l'ACL Web dont vous avez besoin n'existe pas, vous devez en créer une en procédant comme suit :
1. Choisissez **Create Web ACL**.
1. Sur la page d'accueil du service AWS WAF, choisissez **Create web ACL**.
1. Dans **Détails de l'ACL Web**, dans **Nom**, tapez le nom de l'ACL Web.
1. Dans **Règles**, choisissez **Ajouter des règles**, puis **Ajouter mes propres règles et groupes de règles**.
1. Pour **Type de règle**, choisissez IP set pour identifier une liste spécifique d'adresses IP.
1. Pour **Règle**, entrez le nom de la règle.
1. Pour un **ensemble d'adresses IP**, choisissez un ensemble d'adresses IP existant. Pour créer un ensemble d'adresses IP, voir [Création d'un ensemble d'adresses IP](https://docs.aws.amazon.com/waf/latest/developerguide/waf-ip-set-creating.html).
1. Pour l'**adresse IP à utiliser comme adresse d'origine**, choisissez l'**adresse IP dans l'en-tête**.
1. Pour **le nom du champ d'en-tête**, entrez`SourceIP`.
1. Pour **Position dans l'en-tête**, choisissez **Première adresse IP**.
1. Pour **Fallback for missing IP address**, choisissez **Match** ou **No Match** en fonction de la manière dont vous souhaitez gérer une adresse IP non valide (ou manquante) dans l'en-tête.
1. Pour **Action**, choisissez l'action de l'ensemble d'adresses IP.
1. Pour l'**action ACL Web par défaut pour les demandes qui ne correspondent à aucune règle**, choisissez **Autoriser** ou **Bloquer**, puis cliquez sur **Suivant**.
1. Pour les étapes 4 et 5, choisissez **Next**.
1. Dans **Révision et création**, passez en revue vos choix, puis choisissez **Create web ACL**.
1. Choisissez **Save Changes (Enregistrer les modifications)**.
1. Sélectionnez **Ressources**.
1. Pour **Actions**, choisissez **Deploy API**.
Pour plus d'informations sur le niveau de sécurité de Transfer Family avec un pare-feu d'application AWS Web, consultez la section [Securing Transfer Family with AWS application firewall et Amazon API Gateway](https://aws.amazon.com/blogs/storage/securing-aws-transfer-family-with-aws-web-application-firewall-and-amazon-api-gateway/) sur le blog AWS consacré au stockage.
# Prévention du problème de l’adjoint confus entre services
Le problème de député confus est un problème de sécurité dans lequel une entité qui n’est pas autorisée à effectuer une action peut contraindre une entité plus privilégiée à le faire. En AWS, l'usurpation d'identité interservices peut entraîner un problème de confusion chez les adjoints. L’usurpation d’identité entre services peut se produire lorsqu’un service (le *service appelant*) appelle un autre service (le *service appelé*). Le service d'appel peut être manipulé pour utiliser ses autorisations afin d'agir sur les ressources d'un autre client d'une manière à laquelle il ne devrait pas être autorisé à accéder autrement. Pour éviter cela, AWS fournit des outils qui vous aident à protéger vos données pour tous les services avec des principaux de service qui ont eu accès aux ressources de votre compte. Pour une description détaillée de ce problème, voir [le problème de confusion des adjoints](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) dans le *guide de l'utilisateur IAM*.
Nous recommandons d'utiliser les clés contextuelles de condition [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)globale [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)et les clés contextuelles dans les politiques de ressources afin de limiter les autorisations accordées à AWS Transfer Family pour la ressource. Si vous utilisez les deux clés de contexte de condition globale, la valeur `aws:SourceAccount` et le compte de la valeur `aws:SourceArn` doit utiliser le même ID de compte lorsqu’il est utilisé dans la même déclaration de stratégie.
Le moyen le plus efficace de se protéger contre le problème de l’adjoint confus consiste à utiliser l’Amazon Resource Name (ARN) exact de la ressource que vous souhaitez autoriser. Si vous spécifiez plusieurs ressources, utilisez la clé de condition contextuelle `aws:SourceArn` globale avec des caractères génériques (`*`) pour les parties inconnues de l'ARN. Par exemple, `arn:aws:transfer::region::account-id:server/*`.
AWS Transfer Family utilise les types de rôles suivants :
+ **Rôle utilisateur** — Permet aux utilisateurs gérés par le service d'accéder aux ressources Transfer Family nécessaires. AWS Transfer Family assume ce rôle dans le contexte d'un ARN utilisateur de Transfer Family.
+ **Rôle d'accès** — Permet d'accéder uniquement aux fichiers Amazon S3 en cours de transfert. Pour les AS2 transferts entrants, le rôle d'accès utilise le nom de ressource Amazon (ARN) pour l'accord. Pour les AS2 transferts sortants, le rôle d'accès utilise l'ARN du connecteur.
+ **Rôle d'invocation** : à utiliser avec Amazon API Gateway en tant que fournisseur d'identité personnalisé du serveur. Transfer Family assume ce rôle dans le contexte d'un ARN de serveur Transfer Family.
+ **Rôle de journalisation** : utilisé pour enregistrer les entrées sur Amazon CloudWatch. Transfer Family utilise ce rôle pour enregistrer les informations relatives aux réussites et aux échecs ainsi que les informations relatives aux transferts de fichiers. Transfer Family assume ce rôle dans le contexte d'un ARN de serveur Transfer Family. Pour les AS2 transferts sortants, le rôle de journalisation utilise l'ARN du connecteur.
+ **Rôle d'exécution** — Permet à un utilisateur de Transfer Family d'appeler et de lancer des flux de travail. Transfer Family assume ce rôle dans le contexte d'un flux de travail (ARN) Transfer Family.
Pour plus d’informations, consultez [Politiques et autorisations dans IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) dans le *Guide de l’utilisateur IAM*.
**Note**
Dans les exemples suivants, remplacez chacune *user input placeholder* par vos propres informations.
**Note**
Dans nos exemples, nous utilisons à la fois `ArnLike` et`ArnEquals`. Ils sont fonctionnellement identiques et vous pouvez donc utiliser l'un ou l'autre lorsque vous élaborez vos politiques. La documentation Transfer Family `ArnLike` est utilisée lorsque la condition contient un caractère générique et `ArnEquals` pour indiquer une condition de correspondance exacte.
## AWS Transfer Family : rôle d'utilisateur, interservices, prévention des adjoints confus
L'exemple de politique suivant permet à n'importe quel utilisateur de n'importe quel serveur du compte d'assumer le rôle.
****
```
{
"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/*"
}
}
}
]
}
```
L'exemple de politique suivant permet à n'importe quel utilisateur d'un serveur spécifique d'assumer le rôle.
****
```
{
"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/*"
}
}
}
]
}
```
L'exemple de politique suivant permet à un utilisateur spécifique d'un serveur spécifique d'assumer le rôle.
****
```
{
"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 : flux de travail, rôle, interservices, prévention des adjoints confus
L'exemple de politique suivant permet à n'importe quel flux de travail du compte d'assumer le rôle.
****
```
{
"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/*"
}
}
}
]
}
```
L'exemple de politique suivant permet à un flux de travail spécifique d'assumer le rôle.
****
```
{
"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 Transfer Family Connector : rôle, interservices, prévention des adjoints confus
L'exemple de politique suivant permet à n'importe quel connecteur du compte d'assumer le rôle.
****
```
{
"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/*"
}
}
}
]
}
```
L'exemple de politique suivant permet à un connecteur spécifique d'assumer le rôle.
****
```
{
"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 : enregistrement et rôle d'invocation, interservices, prévention des adjoints confus
**Note**
Les exemples suivants peuvent être utilisés à la fois dans les rôles de journalisation et d'invocation.
Dans ces exemples, vous pouvez supprimer les détails de l'ARN d'un flux de travail si aucun flux de travail n'est associé à votre serveur.
L'exemple de logging/invocation politique suivant permet à n'importe quel serveur (et flux de travail) du compte d'assumer le rôle.
****
```
{
"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/*"
]
}
}
}
]
}
```
L'exemple de logging/invocation politique suivant permet à un serveur (et à un flux de travail) spécifiques d'assumer le rôle.
****
```
{
"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 politiques gérées pour AWS Transfer Family
Pour ajouter des autorisations aux utilisateurs, aux groupes et aux rôles, il est plus facile d'utiliser des politiques AWS gérées que de les rédiger vous-même. Il faut du temps et de l'expertise pour [créer des politiques Gestion des identités et des accès AWS (IAM) gérées par le client](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) qui fournissent à votre équipe uniquement les autorisations dont elle a besoin. Pour démarrer rapidement, vous pouvez utiliser nos politiques AWS gérées. Ces politiques couvrent des cas d’utilisation courants et sont disponibles dans votre Compte AWS. Pour plus d’informations sur les politiques gérées par AWS , consultez [Politiques gérées par AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) dans le *Guide de l’utilisateur IAM*. Pour obtenir une liste détaillée de toutes les politiques AWS gérées, consultez le [guide de référence des politiques AWS gérées](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/about-managed-policy-reference.html).
AWS les services maintiennent et mettent à jour les politiques AWS gérées. Vous ne pouvez pas modifier les autorisations dans les politiques AWS gérées. Les services ajoutent occasionnellement des autorisations à une politique gérée par AWS pour prendre en charge de nouvelles fonctionnalités. Ce type de mise à jour affecte toutes les identités (utilisateurs, groupes et rôles) auxquelles la politique est attachée. Les services sont très susceptibles de mettre à jour une politique gérée par AWS quand une nouvelle fonctionnalité est lancée ou quand de nouvelles opérations sont disponibles. Les services ne suppriment pas les autorisations d'une politique AWS gérée. Les mises à jour des politiques n'endommageront donc pas vos autorisations existantes.
En outre, AWS prend en charge les politiques gérées pour les fonctions professionnelles qui couvrent plusieurs services. Par exemple, la politique `ReadOnlyAccess` AWS gérée fournit un accès en lecture seule à tous les AWS services et ressources. Lorsqu'un service lance une nouvelle fonctionnalité, il AWS ajoute des autorisations en lecture seule pour les nouvelles opérations et ressources. Pour obtenir la liste des politiques de fonctions professionnelles et leurs descriptions, consultez la page [politiques gérées par AWS pour les fonctions de tâche](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) dans le *Guide de l’utilisateur IAM*.
## AWS politique gérée : AWSTransfer ConsoleFullAccess
La `AWSTransferConsoleFullAccess` politique fournit un accès complet à Transfer Family via la console AWS de gestion. Pour plus d'informations, consultez la section [Rôle lié à un service pour AWS Transfer Family](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSTransferConsoleFullAccess.html).
## AWS politique gérée : AWSTransfer FullAccess
La `AWSTransferFullAccess` politique fournit un accès complet aux services Transfer Family. Pour plus d'informations, consultez la section [Rôle lié à un service pour AWS Transfer Family](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSTransferFullAccess.html).
## AWS politique gérée : AWSTransfer LoggingAccess
La `AWSTransferLoggingAccess` politique accorde à AWS Transfer Family un accès complet pour créer des flux de journaux et des groupes et pour enregistrer les événements de journal sur votre compte. Pour plus d'informations, consultez la section [Rôle lié à un service pour AWS Transfer Family](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSTransferLoggingAccess.html).
## AWS politique gérée : AWSTransfer ReadOnlyAccess
La `AWSTransferReadOnlyAccess` politique fournit un accès en lecture seule aux services Transfer Family. Pour plus d'informations, consultez la section [Rôle lié à un service pour AWS Transfer Family](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSTransferReadOnlyAccess.html).
## AWS Transfer Family met à jour les politiques AWS gérées
Consultez les détails des mises à jour apportées aux politiques AWS gérées pour AWS Transfer Family depuis que ce service a commencé à suivre ces modifications. Pour obtenir des alertes automatiques sur les modifications apportées à cette page, abonnez-vous au flux RSS de la page [Historique du document pour AWS Transfer Family](doc-history.md).
| Modifier | Description | Date |
| --- | --- | --- |
| Mise à jour de la documentation | Des sections ont été ajoutées pour chacune des politiques gérées par Transfer Family. | 27 janvier 2022 |
| [AWSTransferReadOnlyAccess](#security-iam-awsmanpol-transferreadonlyaccess) : mise à jour d’une politique existante | AWS Transfer Family a ajouté de nouvelles autorisations pour permettre la lecture de la politique AWS Managed Microsoft AD. | 30 septembre 2021 |
| AWS Transfer Family a commencé à suivre les modifications | AWS Transfer Family a commencé à suivre les modifications apportées AWS à ses politiques gérées. | 15 juin 2021 |