Cloudsplaining est un outil d'évaluation de la sécurité AWS IAM qui identifie les violations du moindre privilège et génère un rapport priorisé par risque.
Cloudsplaining est un outil d'évaluation de la sécurité AWS IAM qui identifie les violations du moindre privilège et génère un rapport HTML priorisé par risque.
Pour la documentation complète, veuillez consulter le projet sur ReadTheDocs.
Cloudsplaining identifie les violations du moindre privilège dans les politiques AWS IAM et génère un rapport HTML attrayant. Il peut analyser toutes les politiques de votre compte AWS, sur plusieurs comptes AWS, ou il peut analyser un seul fichier de politique.
Il aide à identifier les actions IAM qui n'exploitent pas les contraintes de ressources. Il aide également à prioriser le processus de correction en signalant les politiques IAM qui présentent les risques suivants pour le compte AWS concerné sans restriction :
s3:GetObject, ssm:GetParameter, secretsmanager:GetSecretValue)Cloudsplaining identifie également les rôles IAM qui peuvent être assumés par les services de calcul AWS (tels que EC2, ECS, EKS ou Lambda), car ils peuvent présenter un plus grand risque que les rôles définis par l'utilisateur - surtout si le service de calcul AWS se trouve sur une instance directement ou indirectement exposée à Internet. Signaler ces rôles est particulièrement utile pour les testeurs de pénétration (ou les attaquants) dans certains scénarios. Par exemple, si un attaquant obtient des privilèges pour exécuter ssm:SendCommand et qu'il existe des instances EC2 privilégiées avec l'agent SSM installé, il peut effectivement avoir les privilèges de ces instances EC2. L'exécution de code à distance via l'agent AWS Systems Manager était déjà un chemin d'escalade/exploitation connu, mais Cloudsplaining peut faciliter le processus d'identification de ces cas. Voir le rapport exemple pour quelques exemples.
Vous pouvez également spécifier un fichier d'exclusions personnalisées pour filtrer les résultats qui sont des faux positifs pour diverses raisons. Par exemple, les politiques utilisateur sont permissives par conception, tandis que les rôles système sont généralement plus restrictifs. Vous pouvez également avoir des exclusions spécifiques à la stratégie multi-comptes de votre organisation ou à l'architecture applicative AWS.
Policy Sentry nous a révélé qu'il est enfin possible d'écrire des politiques IAM conformément au moindre privilège de manière évolutive. Avant la sortie de Policy Sentry, il était trop facile de trouver des documents de politique IAM sans contraintes de ressources. Considérez la politique ci-dessous, qui permet au principal IAM (un rôle ou un utilisateur) d'exécuter s3:PutObject sur n'importe quel compartiment S3 du compte AWS :```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": "*"
}
]
}
C'est mauvais. Idéalement, l'accès devrait être restreint en fonction des ARN de ressources, comme suit :```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::my-bucket/*"
}
]
}
Policy Sentry rend cela très facile. Une fois que les développeurs d'Infrastructure as Code ou les administrateurs AWS se familiarisent avec l'outil (qui est assez facile à utiliser), nous avons constaté que l'adoption commence très rapidement. Cependant, si vous utilisez AWS, il y a probablement un très grand arriéré de politiques IAM qui pourraient bénéficier d'une amélioration. Si vous avez des centaines de comptes AWS avec des dizaines de politiques dans chaque, comment pouvons-nous verrouiller ces comptes AWS en identifiant par programmation les politiques qui doivent être corrigées ?
C'est pourquoi nous avons écrit Cloudsplaining.
Cloudsplaining identifie les violations du moindre privilège dans les politiques AWS IAM et génère un joli rapport HTML. Il peut analyser toutes les politiques de votre compte AWS, sur plusieurs comptes AWS, ou il peut analyser un seul fichier de politique.
brew tap salesforce/cloudsplaining https://github.com/salesforce/cloudsplaining brew install cloudsplaining
#### Pip3```bash
pip3 install --user cloudsplaining
cloudsplaining depuis la ligne de commande en lançant cloudsplaining --help.Pour activer la complétion Bash, placez ceci dans votre .bashrc :```bash
eval "$(_CLOUDSPLAINING_COMPLETE=bash_source cloudsplaining)"
Pour activer la complétion ZSH, mettez ceci dans votre .zshrc:```bash
eval "$(_CLOUDSPLAINING_COMPLETE=zsh_source cloudsplaining)"
Vous pouvez également analyser un seul fichier de politique pour identifier les risques au lieu d'un compte entier.```bash cloudsplaining scan-policy-file --input-file examples/policies/explicit-actions.json
Le résultat inclura une description de la constatation et une liste des actions IAM qui n'utilisent pas de contraintes de ressources.
Le résultat ressemblera à ce qui suit :```console
Issue found: Data Exfiltration
Actions: s3:GetObject
Issue found: Resource Exposure
Actions: ecr:DeleteRepositoryPolicy, ecr:SetRepositoryPolicy, s3:BypassGovernanceRetention, s3:DeleteAccessPointPolicy, s3:DeleteBucketPolicy, s3:ObjectOwnerOverrideToBucketOwner, s3:PutAccessPointPolicy, s3:PutAccountPublicAccessBlock, s3:PutBucketAcl, s3:PutBucketPolicy, s3:PutBucketPublicAccessBlock, s3:PutObjectAcl, s3:PutObjectVersionAcl
Issue found: Unrestricted Infrastructure Modification
Actions: ecr:BatchDeleteImage, ecr:CompleteLayerUpload, ecr:CreateRepository, ecr:DeleteLifecyclePolicy, ecr:DeleteRepository, ecr:DeleteRepositoryPolicy, ecr:InitiateLayerUpload, ecr:PutImage, ecr:PutImageScanningConfiguration, ecr:PutImageTagMutability, ecr:PutLifecyclePolicy, ecr:SetRepositoryPolicy, ecr:StartImageScan, ecr:StartLifecyclePolicyPreview, ecr:TagResource, ecr:UntagResource, ecr:UploadLayerPart, s3:AbortMultipartUpload, s3:BypassGovernanceRetention, s3:CreateAccessPoint, s3:CreateBucket, s3:DeleteAccessPoint, s3:DeleteAccessPointPolicy, s3:DeleteBucket, s3:DeleteBucketPolicy, s3:DeleteBucketWebsite, s3:DeleteObject, s3:DeleteObjectTagging, s3:DeleteObjectVersion, s3:DeleteObjectVersionTagging, s3:GetObject, s3:ObjectOwnerOverrideToBucketOwner, s3:PutAccelerateConfiguration, s3:PutAccessPointPolicy, s3:PutAnalyticsConfiguration, s3:PutBucketAcl, s3:PutBucketCORS, s3:PutBucketLogging, s3:PutBucketNotification, s3:PutBucketObjectLockConfiguration, s3:PutBucketPolicy, s3:PutBucketPublicAccessBlock, s3:PutBucketRequestPayment, s3:PutBucketTagging, s3:PutBucketVersioning, s3:PutBucketWebsite, s3:PutEncryptionConfiguration, s3:PutInventoryConfiguration, s3:PutLifecycleConfiguration, s3:PutMetricsConfiguration, s3:PutObject, s3:PutObjectAcl, s3:PutObjectLegalHold, s3:PutObjectRetention, s3:PutObjectTagging, s3:PutObjectVersionAcl, s3:PutObjectVersionTagging, s3:PutReplicationConfiguration, s3:ReplicateDelete, s3:ReplicateObject, s3:ReplicateTags, s3:RestoreObject, s3:UpdateJobPriority, s3:UpdateJobStatus
Nous pouvons analyser un compte AWS entier et générer des rapports. Pour ce faire, nous utilisons l'appel API AWS IAM get-account-authorization-details, qui télécharge un fichier JSON volumineux (environ 100 Ko par compte) contenant tous les détails IAM du compte. Cela inclut les données sur les utilisateurs, les groupes, les rôles, les politiques gérées par le client et les politiques gérées par AWS.
Vous devez disposer d'informations d'identification AWS configurées qui peuvent être utilisées par la CLI.
Vous devez disposer des privilèges nécessaires pour exécuter iam:GetAccountAuthorizationDetails. La politique arn:aws:iam::aws:policy/SecurityAudit inclut cela, tout comme de nombreuses autres politiques qui autorisent l'accès en lecture au service IAM.
Pour télécharger les détails d'autorisation du compte, assurez-vous d'être authentifié auprès d'AWS, puis exécutez la commande download de cloudsplaining :```bash
cloudsplaining download
* Si vous préférez utiliser votre fichier `~/.aws/credentials` au lieu des variables d'environnement, vous pouvez spécifier le nom du profil :```bash
cloudsplaining download --profile myprofile
Il téléchargera un fichier JSON dans votre répertoire actuel contenant les informations détaillées d'autorisation de votre compte.
L'outil Cloudsplaining ne tente pas de comprendre le contexte derrière tout ce qui se trouve dans votre compte AWS. Il est possible de comprendre le contexte derrière certains de ces éléments de manière programmatique - si la politique est appliquée à un profil d'instance, si la politique est attachée, si des politiques IAM en ligne sont utilisées, et si des politiques gérées AWS sont utilisées. Seul vous connaissez le contexte derrière la conception de votre infrastructure AWS et la stratégie IAM.
En tant que tel, il est important d'éliminer les faux positifs qui dépendent du contexte. Vous pouvez le faire avec un fichier d'exclusions. Nous avons inclus une commande qui générera un fichier d'exclusions pour vous afin que vous n'ayez pas à vous souvenir du format requis.
Vous pouvez créer un modèle d'exclusions via la commande suivante :```bash cloudsplaining create-exclusions-file
Cela générera un fichier dans votre répertoire actuel intitulé `exclusions.yml`.
Maintenant, lorsque vous exécutez la commande `scan`, vous pouvez utiliser le fichier d'exclusions comme ceci :```bash
cloudsplaining scan --exclusions-file exclusions.yml --input-file examples/files/example.json --output examples/files/
Pour plus d'informations sur la structure du fichier d'exclusions, voir Filtering False Positives
Maintenant que nous avons téléchargé le fichier d'autorisation du compte, nous pouvons analyser toutes les politiques AWS IAM avec cloudsplaining.
Exécutez la commande suivante:```bash cloudsplaining scan --exclusions-file exclusions.yml --input-file examples/files/example.json --output examples/files/
Cela créera un rapport HTML comme [ceci](https://opensource.salesforce.com/cloudsplaining/) :
> 
Cela créera également un fichier de données JSON brut:
* `default-iam-results.json`: Ce fichier contient la sortie JSON brute du rapport. Vous pouvez utiliser ce fichier de données pour exploiter les résultats d'analyse à diverses fins. Par exemple, vous pourriez écrire un script Python qui analyse ces données et crée automatiquement des tickets JIRA ou des éléments de travail Salesforce. Un exemple d'entrée est présenté ci-dessous. L'exemple complet peut être consulté sur [examples/files/iam-results-example.json](https://github.com/salesforce/cloudsplaining/blob/master/examples/files/iam-results-example.json)```json
{
"example-authz-details": [
{
"AccountID": "012345678901",
"ManagedBy": "Customer",
"PolicyName": "InsecureUserPolicy",
"Arn": "arn:aws:iam::012345678901:user/userwithlotsofpermissions",
"ActionsCount": 2,
"ServicesCount": 1,
"Actions": [
"s3:PutObject",
"s3:PutObjectAcl"
],
"Services": [
"s3"
]
}
]
}
Les contraintes de ressources sont une bonne pratique - en particulier pour les rôles système/profils d'instance - mais parfois, elles sont intentionnelles. Par exemple, considérons une situation où une politique IAM personnalisée est utilisée sur un profil d'instance pour une instance EC2 qui provisionne Terraform. Dans ce cas, des permissions étendues sont des exigences de conception - nous ne voulons donc pas inclure celles-ci dans les résultats.
Vous pouvez créer un modèle d'exclusion via la commande suivante :```bash cloudsplaining create-exclusions-file
Cela générera un fichier dans votre répertoire actuel intitulé `exclusions.yml`.
Le fichier d'exclusions par défaut ressemble à ceci :```yaml
# Policy names to exclude from evaluation
# Suggestion: Add policies here that are known to be overly permissive by design, after you run the initial report.
policies:
- "AWSServiceRoleFor*"
- "*ServiceRolePolicy"
- "*ServiceLinkedRolePolicy"
- "AdministratorAccess" # Otherwise, this will take a long time
- "service-role*"
- "aws-service-role*"
# Don't evaluate these roles, users, or groups as part of the evaluation
roles:
- "service-role*"
- "aws-service-role*"
users:
- ""
groups:
- ""
# Read-only actions to include in the results, such as s3:GetObject
# By default, it includes Actions that could lead to Data Exfiltration
include-actions:
- "s3:GetObject"
- "ssm:GetParameter"
- "ssm:GetParameters"
- "ssm:GetParametersByPath"
- "secretsmanager:GetSecretValue"
# Write actions to include from the results, such as kms:Decrypt
exclude-actions:
- ""
policies, listez le chemin des noms de politiques que vous souhaitez exclure.MyRole, listez MyRole ou MyR* dans la liste roles.users et groups.Maintenant, lorsque vous exécutez la commande scan, vous pouvez utiliser le fichier d'exclusions comme ceci :```bash
cloudsplaining scan --exclusions-file exclusions.yml --input-file examples/files/example.json --output examples/files/
### Analyse de plusieurs comptes AWS
Si votre utilisateur IAM ou votre rôle IAM dispose des autorisations `sts:AssumeRole` pour un rôle IAM commun sur plusieurs comptes AWS, vous pouvez utiliser la commande `scan-multi-account`.
Ce diagramme illustre le fonctionnement du processus :
> Note : Si vous débutez dans la configuration d'accès entre comptes, consultez [le tutoriel officiel AWS sur la délégation d'accès entre comptes AWS à l'aide de rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html). Cela peut vous aider à mettre en place l'architecture ci-dessus.
* Tout d'abord, vous devez créer le fichier de configuration multi-comptes. Exécutez la commande suivante :```bash
cloudsplaining create-multi-account-config-file \
-o multi-account-config.yml
multi-account-config.yml avec le contenu suivant :```yaml
accounts:
default_account: 123456789012
prod: 123456789013
test: 123456789014> Remarque : Observez comment le format du fichier ci-dessus inclut `account_name: accountID`. Modifiez le contenu du fichier pour qu'il corresponde au nom de compte et à l'ID de compte souhaités. Incluez autant d'ID de compte que vous le souhaitez.
Pour l'étape suivante, supposons que :
* Nous avons un rôle dans les comptes cibles qui s'appelle `CommonSecurityRole`.
* Les identifiants de votre utilisateur IAM se trouvent sous le profil d'identifiants AWS appelé `scanning-user`.
* Cet utilisateur a les permissions `sts:AssumeRole` pour assumer le `CommonSecurityRole` dans tous vos comptes cibles spécifiés dans le fichier YAML que nous avons créé précédemment.
* Vous souhaitez sauvegarder la sortie dans un bucket S3 appelé `my-results-bucket`.
En utilisant les données ci-dessus, vous pouvez exécuter la commande suivante :```bash
cloudsplaining scan-multi-account \
-c multi-account-config.yml \
--profile scanning-user \
--role-name CommonSecurityRole \
--output-bucket my-results-bucket
Notez que si vous exécutez ce qui précède sans le drapeau
--profile, il s'exécutera selon l'ordre de priorité standard des informations d'identification AWS (c'est-à-dire variables d'environnement, profils d'informations d'identification, informations d'identification de conteneur ECS, puis enfin informations d'identification de profil d'instance EC2).
Cloudsplaining prend en charge la personnalisation des sections Guidance et Annexes du rapport HTML pour inclure des recommandations et de la documentation de sécurité spécifiques à l'organisation.
Placez les fichiers HTML dans le répertoire racine de votre projet :
custom-guidance.html - Contenu de guidance de sécurité personnalisécustom-appendices.html - Contenu d'annexes personnaliséecho '
Follow these organization-specific steps:
echo '
Additional company resources:
cloudsplaining download
cloudsplaining download --profile someprofile
cloudsplaining scan --input-file default.json
cloudsplaining scan --input-file default.json --exclusions-file exclusions.yml
cloudsplaining scan-policy-file --input-file examples/policies/wildcards.json cloudsplaining scan-policy-file --input-file examples/policies/wildcards.json --exclusions-file examples/example-exclusions.yml
cloudsplaining create-multi-account-config-file -o accounts.yml cloudsplaining scan-multi-account -c accounts.yml -r TargetRole --output-directory ./
## FAQ
**Analysera-t-il toutes les politiques par défaut ?**
Non, il analysera uniquement les politiques attachées aux principaux IAM.
**La commande de téléchargement téléchargera-t-elle toutes les versions des politiques ?**
Non par défaut. Si vous souhaitez le faire, spécifiez le drapeau `--include-non-default-policy-versions`. Notez que l'outil `scan` ne fonctionne actuellement pas sur les versions non par défaut.
**J'ai suivi les instructions d'installation mais je ne peux pas exécuter le programme en ligne de commande du tout. Que dois-je faire ?**
C'est probablement un problème avec votre PATH. Votre variable d'environnement PATH ne prend pas en compte les paquets binaires installés par `pip3`. Sur un Mac, vous pouvez probablement résoudre ce problème en saisissant la commande ci-dessous, selon les versions que vous avez installées. YMMV.```bash
export PATH=$HOME/Library/Python/3.7/bin/:$PATH
J'ai suivi les instructions d'installation, mais je reçois une ModuleNotFoundError indiquant No module named policy_sentry.analysis.expand. Que dois-je faire ?
Essayez de mettre à jour vers la dernière version de Cloudsplaining. Cette erreur a été corrigée dans la version 0.0.10.