Cloudsplaining é uma ferramenta de Avaliação de Segurança AWS IAM que identifica violações do princípio do menor privilégio e gera um relatório priorizado por risco.
Para documentação completa, consulte o projeto no ReadTheDocs.
O Cloudsplaining identifica violações do princípio do menor privilégio em políticas IAM da AWS e gera um relatório HTML elegante. Ele pode verificar todas as políticas em sua conta AWS, em várias contas AWS ou pode verificar um único arquivo de política.
Ele ajuda a identificar ações IAM que não aproveitam restrições de recursos. Também auxilia na priorização do processo de remediação, sinalizando políticas IAM que apresentam os seguintes riscos à conta AWS em questão, sem restrição:
s3:GetObject, ssm:GetParameter, secretsmanager:GetSecretValue)O Cloudsplaining também identifica Roles IAM que podem ser assumidas por Serviços de Computação da AWS (como EC2, ECS, EKS ou Lambda), pois podem apresentar maior risco do que roles definidas por usuários – especialmente se o serviço de computação AWS estiver em uma instância que está direta ou indiretamente exposta à internet. Sinalizar essas roles é particularmente útil para testadores de penetração (ou invasores) em determinados cenários. Por exemplo, se um invasor obtiver privilégios para executar ssm:SendCommand e houver instâncias EC2 privilegiadas com o agente SSM instalado, ele poderá efetivamente ter os privilégios dessas instâncias EC2. A Execução Remota de Códigos por meio do AWS Systems Manager Agent já era um caminho conhecido de escalada/exploração, mas o Cloudsplaining pode facilitar o processo de identificação desses casos. Veja o relatório de exemplo para alguns exemplos.
Você também pode especificar um arquivo de exclusão personalizado para filtrar resultados que são Falsos Positivos por diversos motivos. Por exemplo, Políticas de Usuário são permissivas por design, enquanto roles de Sistema são geralmente mais restritivas. Você também pode ter exclusões específicas para a estratégia de múltiplas contas ou arquitetura de aplicações AWS da sua organização.
O Policy Sentry revelou que é possível, finalmente, escrever políticas IAM de acordo com o princípio do menor privilégio de forma escalável. Antes do lançamento do Policy Sentry, era muito fácil encontrar documentos de política IAM sem restrições de recursos. Considere a política abaixo, que permite ao principal IAM (um role ou usuário) executar s3:PutObject em qualquer bucket S3 na conta AWS:```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": "*"
}
]
}
Isso é ruim. Idealmente, o acesso deve ser restrito de acordo com ARNs de recursos, assim:```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::my-bucket/*"
}
]
}
Policy Sentry torna isso realmente fácil. Uma vez que os desenvolvedores de Infrastructure as Code ou Administradores AWS ganhem familiaridade com a ferramenta (que é bastante fácil de usar), descobrimos que a adoção começa muito rapidamente. No entanto, se você tem usado AWS, provavelmente há um grande backlog de políticas IAM que poderiam ser melhoradas. Se você tem centenas de contas AWS com dezenas de políticas em cada uma, como podemos restringir essas contas AWS identificando programaticamente as políticas que devem ser corrigidas?
Foi por isso que escrevemos o Cloudsplaining.
Cloudsplaining identifica violações do princípio do menor privilégio em políticas IAM da AWS e gera um relatório HTML bonito. Ele pode escanear todas as políticas na sua conta AWS, em várias contas AWS, ou pode escanear um único arquivo de política.
brew tap salesforce/cloudsplaining https://github.com/salesforce/cloudsplaining brew install cloudsplaining
#### Pip3```bash
pip3 install --user cloudsplaining
cloudsplaining a partir da linha de comando executando cloudsplaining --help.Para habilitar o completamento do Bash, coloque isto em seu .bashrc:```bash
eval "$(_CLOUDSPLAINING_COMPLETE=bash_source cloudsplaining)"
Para habilitar o autocompletar ZSH, coloque isto no seu .zshrc:```bash
eval "$(_CLOUDSPLAINING_COMPLETE=zsh_source cloudsplaining)"
Você também pode analisar um único arquivo de política para identificar riscos em vez de uma conta inteira.```bash cloudsplaining scan-policy-file --input-file examples/policies/explicit-actions.json
A saída incluirá uma descrição do achado e uma lista das ações do IAM que não utilizam restrições de recursos.
A saída será semelhante ao seguinte:```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
Podemos escanear uma conta AWS inteira e gerar relatórios. Para fazer isso, utilizamos a chamada de API do AWS IAM get-account-authorization-details, que baixa um grande arquivo JSON (cerca de 100KB por conta) contendo todos os detalhes do IAM para a conta. Isso inclui dados sobre usuários, grupos, funções, políticas gerenciadas pelo cliente e políticas gerenciadas pela AWS.
Você deve ter credenciais AWS configuradas que possam ser usadas pela CLI.
Você deve ter privilégios para executar iam:GetAccountAuthorizationDetails. A política arn:aws:iam::aws:policy/SecurityAudit inclui isso, assim como muitas outras que permitem acesso de leitura ao serviço IAM.
Para baixar os detalhes de autorização da conta, certifique-se de estar autenticado na AWS e execute o comando download do cloudsplaining:```bash
cloudsplaining download
* Se preferir usar o arquivo `~/.aws/credentials` em vez de variáveis de ambiente, você pode especificar o nome do perfil:```bash
cloudsplaining download --profile myprofile
Ele baixará um arquivo JSON no seu diretório atual que contém informações detalhadas de autorização da sua conta.
A ferramenta Cloudsplaining não tenta entender o contexto por trás de tudo na sua conta AWS. É possível entender o contexto por trás de algumas dessas coisas programaticamente - se a política está aplicada a um instance profile, se a política está attached, se as inline IAM policies estão em uso, e se as AWS Managed Policies estão em uso ou não. Somente você conhece o contexto por trás do design da sua infraestrutura AWS e da estratégia IAM.
Como tal, é importante eliminar Falsos Positivos que dependem do contexto. Você pode fazer isso com um arquivo de exclusões. Incluímos um comando que gerará um arquivo de exclusões para você, para que não precise lembrar do formato exigido.
Você pode criar um modelo de exclusões através do seguinte comando:
cloudsplaining create-exclusions-file
``````bash
cloudsplaining create-exclusions-file
Isso irá gerar um arquivo no seu diretório atual chamado exclusions.yml.
Agora, quando você executar o comando scan, pode usar o arquivo de exclusões desta forma:```bash
cloudsplaining scan --exclusions-file exclusions.yml --input-file examples/files/example.json --output examples/files/
Para mais informações sobre a estrutura do arquivo de exclusões, veja [Filtrando Falsos Positivos](#filtering-false-positives)
#### Escaneando o arquivo de Detalhes de Autorização
Agora que baixamos o arquivo de autorização da conta, podemos escanear *todas* as políticas AWS IAM com `cloudsplaining`.
Execute o seguinte comando:```bash
cloudsplaining scan --exclusions-file exclusions.yml --input-file examples/files/example.json --output examples/files/
Isso criará um relatório HTML como este:
Também criará um arquivo de dados JSON bruto:
default-iam-results.json: Este contém a saída JSON bruta do relatório. Você pode usar este arquivo de dados para operar nos resultados da varredura para diversos fins. Por exemplo, você poderia escrever um script Python que analisa esses dados e abre automaticamente issues JIRA ou Work Items do Salesforce. Um exemplo de entrada é mostrado abaixo. O exemplo completo pode ser visualizado em 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"
]
}
]
}Veja a pasta [examples/files](https://github.com/salesforce/cloudsplaining/blob/master/examples/files) para exemplos de saída.
#### Filtragem de Falsos Positivos
Restrições de recursos são boas práticas — especialmente para funções de sistema/perfis de instância — mas, às vezes, são propositais. Por exemplo, considere uma situação em que uma política IAM personalizada é usada em um perfil de instância para uma instância EC2 que provisiona Terraform. *Nesse caso, permissões amplas são requisitos de design* — portanto, não queremos incluí-las nos resultados.
Você pode criar um modelo de exclusões através do seguinte comando:```bash
cloudsplaining create-exclusions-file
Isso irá gerar um arquivo no seu diretório atual chamado exclusions.yml.
O arquivo de exclusões padrão tem esta aparência:```yaml
policies:
roles:
include-actions:
exclude-actions:
* Faça quaisquer adições ou modificações que desejar.
* Em `policies`, liste o caminho dos nomes de políticas que deseja excluir.
* Se quiser excluir uma função chamada `MyRole`, liste `MyRole` ou `MyR*` na lista `roles`.
* Você pode seguir a mesma abordagem para as listas `users` e `groups`.
Agora, ao executar o comando `scan`, você pode usar o arquivo de exclusões assim:```bash
cloudsplaining scan --exclusions-file exclusions.yml --input-file examples/files/example.json --output examples/files/
Se seu usuário IAM ou função IAM tem permissões sts:AssumeRole para uma função IAM comum em várias contas AWS, você pode usar o comando scan-multi-account.
Este diagrama ilustra como o processo funciona:
Nota: Se você é novo na configuração de acesso entre contas, confira o tutorial oficial da AWS sobre Delegação de acesso entre contas AWS usando funções IAM. Isso pode ajudá-lo a configurar a arquitetura acima.
* Isso irá gerar um arquivo chamado `multi-account-config.yml` com o seguinte conteúdo:```yaml
accounts:
default_account: 123456789012
prod: 123456789013
test: 123456789014
Nota: Observe como o formato do arquivo acima inclui
account_name: accountID. Edite o conteúdo do arquivo para corresponder ao nome de conta e ID de conta desejados. Inclua quantos IDs de conta desejar.
Para o próximo passo, vamos considerar que:
CommonSecurityRole.scanning-user.sts:AssumeRole para assumir a CommonSecurityRole em todas as suas contas de destino especificadas no arquivo YAML que criamos anteriormente.my-results-bucketUsando os dados acima, você pode executar o seguinte comando:```bash
cloudsplaining scan-multi-account
-c multi-account-config.yml
--profile scanning-user
--role-name CommonSecurityRole \
--output-bucket my-results-bucket
> Observe que, se você executar o comando acima sem a flag `--profile`, ele será executado seguindo a [ordem de precedência de credenciais AWS padrão](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default) (ou seja, variáveis de ambiente, perfis de credenciais, credenciais do contêiner ECS e, por fim, credenciais do perfil de instância EC2).
## Orientação Personalizada e Apêndices
O Cloudsplaining permite personalizar as seções de Orientação e Apêndices do relatório HTML para incluir recomendações e documentações de segurança específicas da organização.
### Como Funciona
Coloque os arquivos HTML no diretório raiz do seu projeto:
- `custom-guidance.html` - Conteúdo de orientação de segurança personalizada
- `custom-appendices.html` - Conteúdo de apêndices personalizados
### Comportamento
- **Arquivos não existem**: Mostra as recomendações de segurança padrão da AWS
- **Arquivos existem com conteúdo**: Mostra o conteúdo HTML personalizado
- **Arquivos existem mas estão vazios**: Oculta as abas por completo
- **Configuração mista**: Cada aba funciona de forma independente
### Exemplo de Uso```bash
# Create custom guidance
echo '<h1>Company Security Guidelines</h1>
<p>Follow these organization-specific steps:</p>
<ul>
<li>Review with security team</li>
<li>Document in JIRA ticket</li>
<li>Get approval before remediation</li>
</ul>' > custom-guidance.html
# Create custom appendices
echo '<h1>Internal Resources</h1>
<p>Additional company resources:</p>
<ul>
<li><a href="https://internal.company.com/security">Security Portal</a></li>
<li><a href="https://wiki.company.com/iam">IAM Best Practices</a></li>
</ul>' > custom-appendices.html
cloudsplaining scan --input-file account-data.json --output reports/
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
**Ele irá analisar todas as políticas por padrão?**
Não, ele apenas irá analisar políticas que estão anexadas a entidades principais do IAM.
**O comando de download irá baixar todas as versões de política?**
Não por padrão. Se quiser fazer isso, especifique a flag `--include-non-default-policy-versions`. Observe que a ferramenta `scan` atualmente não opera em versões não padrão.
**Segui as instruções de instalação, mas não consigo executar o programa via linha de comando. O que devo fazer?**
Isso provavelmente é um problema com o seu PATH. Sua variável de ambiente PATH não está considerando os pacotes binários instalados pelo `pip3`. Em um Mac, você provavelmente pode corrigir isso digitando o comando abaixo, dependendo das versões que você tem instaladas. YMMV (sua milhagem pode variar).```bash
export PATH=$HOME/Library/Python/3.7/bin/:$PATH
Segui as instruções de instalação, mas estou recebendo um ModuleNotFoundError que diz No module named policy_sentry.analysis.expand. O que devo fazer?
Tente atualizar para a versão mais recente do Cloudsplaining. Este erro foi corrigido na versão 0.0.10.