gabrielsoltz/metahubFerramenta automatizada de enriquecimento de descobertas de segurança e avaliação de impacto para AWS. Enriquece dados de vulnerabilidades com contexto de recursos, associações e tags para calcular pontuações de impacto contextuais para remediação priorizada.
MetaHub é uma ferramenta automatizada de enriquecimento contextual de achados de segurança e avaliação de impacto para gerenciamento de vulnerabilidades. Você pode usá-la com AWS Security Hub ou qualquer scanner de segurança compatível com ASFF. Pare de confiar em severidades inúteis e mude para definições de pontuação de impacto baseadas no SEU contexto.
MetaHub é uma ferramenta de segurança de código aberto para gerenciamento de vulnerabilidades com impacto contextual. Ela pode automatizar o processo de contextualizar achados de segurança com base no seu ambiente e nas suas necessidades, no SEU contexto, identificar propriedade e calcular uma pontuação de impacto baseada nisso que você pode usar para definir priorização (por onde começar?) e automações como remediações, alertas ou tickets. A ferramenta é para ambientes AWS e você pode usá-la com AWS Security Hub ou qualquer scanner compatível com ASFF (como Prowler).
ℹ️ Explore e amplie os novos Painéis MetaHub usando Powerpipe!
MetaHub descreve seu contexto conectando-se aos seus recursos afetados em suas contas afetadas. Ele pode descrever informações sobre sua conta e organização AWS, as tags dos recursos afetados, eventos relacionados do CloudTrail, as configurações dos seus recursos afetados e todas as suas associações: se você está contextualizando um achado de segurança que afeta uma instância EC2, o MetaHub não apenas se conectará a essa instância, mas também às suas IAM Roles; a partir daí, ele se conectará às IAM Policies associadas a essas roles. Ele se conectará aos Security Groups e analisará todas as suas regras, à VPC e às Subnets onde a instância está em execução, aos Volumes, aos Auto Scaling Groups e muito mais. Você pode aplicar filtros para automatizar a detecção de outros recursos com as mesmas propriedades e realizar investigações aprofundadas.
Após buscar todas as informações do seu contexto, o MetaHub avaliará as condições de impacto para todos os seus recursos: exposição, acesso, criptografia, status, ambiente, aplicação e proprietário. Com base nesses cálculos e, além das informações sobre os achados de segurança que afetam o recurso, todos juntos, o MetaHub gerará uma pontuação para cada achado e recurso afetado.
Confira o seguinte painel gerado pelo MetaHub. Você tem os recursos afetados, agrupando todos os achados de segurança que os afetam juntamente com a severidade original de cada achado. Depois disso, você tem a pontuação e todos os critérios que o MetaHub avaliou para gerar essa pontuação. Todas essas informações são filtráveis, ordenáveis, agrupáveis, baixáveis e personalizáveis.
O seguinte é a saída JSON para uma instância EC2; veja como o MetaHub organiza todas as informações sobre seu contexto juntas, sob associações, config, tags, account e cloudtrail, e finalmente a chave impact com a pontuação e todos os critérios avaliados para gerar essa pontuação.
MetaHub oferece uma variedade de formas para listar, gerenciar e exportar seus achados de segurança para investigação, supressão, atualização e integração com outras ferramentas. Ele é projetado para uso como ferramenta CLI ou em fluxos de trabalho automatizados, como funções AWS Lambda. Suporta diferentes saídas, algumas delas json programático, mas também poderosas html, xlsx e csv que você pode personalizar.
Se você usa AWS Security Hub, o MetaHub se integra suavemente e estende suas funcionalidades. Ele pode ser usado como uma Ação Personalizada do Security Hub, suporta filtros do AWS Security Hub, você pode gerenciar o status do fluxo de trabalho dos seus achados e pode até mesmo enriquecer seus achados diretamente no AWS Security Hub.
O MetaHub é projetado para uso com AWS e suporta configurações multi-conta. Você pode executar a ferramenta de qualquer ambiente assumindo papéis na sua conta master do AWS Security Hub e nas suas contas child/service. Isso permite buscar dados agregados de várias contas usando sua implementação multi-conta do AWS Security Hub, enquanto também busca e enriquece esses achados com dados das contas onde seus recursos afetados estão sendo executados. Consulte Configurando o Security Hub para mais informações.
Leia seus achados de segurança do AWS Security Hub com os filtros padrão e execute as opções de contexto padrão:```bash ./metahub
Lê um achado de segurança específico (filtrado por Id) do AWS Security Hub e executa as opções de contexto padrão:```bash
./metahub --sh-filters Id=arn:aws:securityhub:us-east-1:123456789012:security-control/CloudFront.1/finding/8bd4d049-dcbc-445b-a5d1-595d8274b4c1
Lê todas as descobertas de segurança que afetam um recurso que estão ACTIVE (filtradas por ResourceId e RecordState) do AWS Security Hub e executa as opções de contexto padrão:```bash ./metahub --sh-filters RecordState=ACTIVE ResourceId=arn:aws:ec2:eu-west-1:123456789012:subnet/subnet-0b7d243ff90ebc03e
Ler todas as descobertas de segurança que afetam uma conta AWS que estão ATIVAS (filtradas por AwsAccountId e RecordState) para recursos com uma tag `Environment` e o valor `stg` e executa as opções de contexto `config` e `tags`:```bash
./metahub --sh-filters RecordState=ACTIVE AwsAccountId=123456789012 --mh-filters-tags Environment=stg --context config tags
Leia suas descobertas de segurança do Prowler como um arquivo de entrada e execute as opções de contexto padrão:```bash python3 prowler.py aws -M json-asff -q ./metahub --inputs file-asff --input-asff /path/to/prowler-findings.json.asff
Leia as suas descobertas de segurança do Powerpipe como um ficheiro de entrada e execute as opções de contexto padrão:```bash
powerpipe benchmark run aws_compliance.benchmark.all_controls --export asff
./metahub --inputs file-asff --input-asff /path/to/powerpipe-findings.json.asff
Leia suas descobertas de segurança do Trivy como um arquivo de entrada e execute as opções de contexto padrão:```bash export AWS_REGION=us-west-1 export AWS_ACCOUNT_ID=012345678901 trivy image --format template --template "@contrib/asff.tpl" -o trivy-findings.json.asff public.ecr.aws/n2p8q5p4/metahub:stable ./metahub --inputs file-asff --input-asff /path/to/trivy-findings.json.asff
# Contexto
No **MetaHub**, **contexto** refere-se a informações sobre os recursos afetados, como sua **configuração**, **associações**, **logs**, **tags** e **conta**.
O MetaHub não para no recurso afetado, mas também analisa quaisquer recursos associados ou anexados. Por exemplo, se um achado de segurança existir em um Security Group, o **MetaHub** analisará o Security Group e tudo mais associado a ele, como as instâncias EC2 que o utilizam. Para cada recurso associado, o **MetaHub** buscará seu contexto. Se o Security Group estiver anexado a uma Instância EC2, o **MetaHub** analisará a instância e todas as suas associações, como as Roles do IAM e políticas. A partir de um único achado de segurança em um Security Group, o **MetaHub** buscará o contexto do Security Group, da Instância EC2, das Roles do IAM e das Políticas do IAM. Isso é essencial para entender o impacto dos seus achados de segurança.
O módulo **context** tem cinco partes principais: [**config**](#config) (que inclui [**associations**](#associations)), [**tags**](#tags), [**cloudtrail**](#cloudtrail) e [**account**](#account). Por padrão, apenas **config**, **tags** e **account** estão habilitados, mas você pode alterar esse comportamento usando a opção `--context` (por exemplo, use `--context config tags cloudtrail account` para habilitar todas as chaves de contexto, ou `--context config` para habilitar apenas a chave config e associações.):
## Config
Na chave `config`, você pode encontrar configurações importantes do recurso afetado. Por exemplo, se o recurso afetado for um Bucket S3, você encontrará informações sobre sua política de bucket, suas ACLs, sua configuração de criptografia e mais. Se o recurso afetado for uma Instância EC2, você encontrará informações sobre sua chave, seus IPs público e privado, seus metadados e mais. As informações de configuração que o **MetaHub** busca são definidas por tipo de recurso. Se você quiser adicionar mais informações de configuração, veja [contribuição](#contributing).
Você pode filtrar seus achados com base nas saídas de configuração usando a opção: `--mh-filters-config <key> {True/False}` (veja [filtros de configuração](#config-filters)).
<details>
<summary>Exemplo para a chave de configuração de um bucket S3</summary>```json
"config": {
"resource_policy": {
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Test",
"Effect": "Allow",
"Principal": {
"Service": "config.amazonaws.com"
},
"Action": "s3:GetBucketAcl",
"Resource": "arn:aws:s3:::metahub-bucket",
"Condition": {
"StringEquals": {
"AWS:SourceAccount": "123456789012"
}
}
},
]
},
"website_enabled": false,
"bucket_acl": [
{
"Grantee": {
"DisplayName": "gabriel.soltz",
"ID": "1234564bd76c6c64080717b68eafaa588b41706daaf22d3d0705b398bd7cbd57",
"Type": "CanonicalUser"
},
"Permission": "FULL_CONTROL"
}
],
"cannonical_user_id": "1234564bd76c6c64080717b68eafaa588b41706daaf22d3d0705b398bd7cbd57",
"public_access_block_enabled": {
"BlockPublicAcls": true,
"IgnorePublicAcls": true,
"BlockPublicPolicy": true,
"RestrictPublicBuckets": true
},
"account_public_access_block_enabled": false,
"public": false,
"bucket_encryption": [
{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
},
"BucketKeyEnabled": false
}
]
},
Na chave associations, você encontrará todos os recursos associados ao recurso afetado. Por exemplo, se o recurso afetado for uma EC2 Instance, você encontrará recursos como: Security Groups, IAM Roles, Volumes, VPC, Subnets, Auto Scaling Groups. Se o recurso afetado for uma IAM Role, você encontrará recursos como IAM Policies, IAM Users, IAM Groups e mais. Cada vez que o MetaHub encontra uma associação, ele se conecta novamente ao recurso associado e obtém seu próprio contexto. As associações são fundamentais para entender o contexto e o impacto das suas descobertas de segurança.
Você pode filtrar suas descobertas com base nas saídas das associações usando a opção: --mh-filters-config <key> {True/False} (veja config filters).
Sob a chave tags, você encontrará todas as tags associadas ao recurso afetado. MetaHub depende da AWS Resource Groups Tagging API para consultar as tags associadas aos seus recursos. Observe que nem todos os tipos de recurso da AWS suportam esta API. Você pode verificar os serviços suportados.
As tags são uma parte crucial para entender seu contexto. Estratégias de tagging geralmente incluem:
Se você seguir uma estratégia de tagging adequada, poderá filtrar e gerar saídas interessantes. Por exemplo, você poderia listar todas as descobertas relacionadas a uma equipe específica e fornecer esses dados diretamente a essa equipe.
Você pode filtrar suas descobertas com base nas saídas de tags usando a opção: --mh-filters-tags TAG=VALUE (veja filtros de tags).
Na chave cloudtrail, você encontrará eventos críticos do CloudTrail relacionados ao recurso afetado, como eventos de criação. Os eventos do CloudTrail que procuramos são definidos por tipo de recurso, e você pode adicionar, remover ou alterá-los editando o arquivo de configuração resources.py. Por exemplo, para um recurso afetado do tipo Security Group, o MetaHub procurará os seguintes eventos: CreateSecurityGroup (evento de criação de Security Group) e AuthorizeSecurityGroupIngress (evento de autorização de regra de Security Group).
Sob a chave account, você encontrará informações sobre a conta onde o recurso afetado está em execução, como se faz parte de uma AWS Organizations, informações sobre seus contatos e mais.
O módulo de impacto no MetaHub foca em entender as 7 propriedades-chave do recurso afetado: exposure, access, encryption, status, environment, application e owner e combinar seus valores com os valores de todas as descobertas de segurança que afetam o mesmo recurso e suas gravidades para gerar uma pontuação. A pontuação de impacto é um número entre 0 e 100, onde 100 é o maior impacto.
Exposição avalia como o recurso afetado está exposto a outras redes. Por exemplo, se o recurso afetado é efetivamente público ou apenas público, se faz parte de uma VPC, se possui um IP público ou se está protegido por um firewall ou grupo de segurança.
Acesso avalia a camada de política de recursos. MetaHub verifica todas as políticas disponíveis, incluindo: políticas gerenciadas do IAM, políticas inline do IAM, políticas de recursos, ACLs de bucket e qualquer associação a outros recursos, como funções do IAM, cujas políticas também são analisadas. Uma política irrestrita não é apenas um problema em si, ela afeta qualquer outro recurso que a esteja usando.
Criptografia avalia as diferentes camadas de criptografia com base em cada tipo de recurso. Por exemplo, para alguns recursos, avalia se a configuração de criptografia at_rest e in_transit estão ambas ativadas.
| Status Possíveis |
|---|
O Status avalia o estado do recurso afetado em termos de anexação ou funcionamento. Por exemplo, para uma EC2 Instance, avaliamos se o recurso está em execução, parado ou terminado, mas para recursos como EBS Volumes e Security Groups, avaliamos se esses recursos estão anexados a qualquer outro recurso.
Ambiente avalia o ambiente onde o recurso afetado está sendo executado. Por padrão, o MetaHub define 3 ambientes: production, staging e development, mas você pode adicionar, remover ou modificar esses ambientes de acordo com suas necessidades. O MetaHub avalia o ambiente com base nas tags do recurso afetado, no id da conta ou no alias da conta. Você pode definir suas próprias definições e estratégia de ambientes no arquivo de configuração (veja Customizando a Configuração).
Aplicação avalia a aplicação da qual o recurso afetado faz parte. O MetaHub depende do recurso myApplications da AWS, que por sua vez depende da Tag awsApplication, mas você pode estender essa funcionalidade com base no seu contexto, por exemplo, definindo outras tags que você usa para definir aplicações ou serviços (como Service ou qualquer outra), ou contando com o ID ou alias da conta. Você pode definir suas definições e estratégia de aplicação no arquivo de configuração (consulte Personalizando a Configuração).
| Possíveis Status | Valor | Descrição |
|---|---|---|
| 🔵 desconhecido | - | O recurso não pôde ser verificado para a aplicação. |
Proprietário concentra-se na detecção de propriedade. Ele pode determinar o proprietário do recurso afetado de várias maneiras. Essas informações podem ser usadas para atribuir automaticamente um achado de segurança ao proprietário correto, escaloná-lo ou tomar decisões com base nessas informações. Uma maneira automatizada de determinar o proprietário de um recurso é crítica para as equipes de segurança. Isso permite que elas se concentrem nas questões mais críticas e as atribuam o mais rápido possível às pessoas certas em fluxos de trabalho automatizados. Você pode definir suas definições de proprietário e estratégia no arquivo de configuração (Consulte Personalizando a Configuração).
| Status Possíveis | Valor | Descrição |
|---|---|---|
| 🔵 desconhecido | - | O recurso não pôde ser verificado quanto ao proprietário. |
Como parte do cálculo da pontuação de impacto, também avaliamos a quantidade total de descobertas de segurança e suas severidades que afetam o recurso. Usamos a seguinte fórmula para calcular esta métrica:```sh (SUM of all (Finding Severity / Highest Severity) with a maximum of 1)
Por exemplo, se o recurso afetado tem duas descobertas que o afetam, uma com severidade `HIGH` e outra com `LOW`, a **Pontuação de Impacto das Descobertas** será:```sh
SUM(HIGH (3) / CRITICAL (4) + LOW (0.5) / CRITICAL (4)) = 0.875
MetaHub lê suas descobertas de segurança do AWS Security Hub ou de qualquer scanner de segurança compatível com ASFF. Em seguida, consulta os recursos afetados diretamente na conta afetada para fornecer contexto adicional. Com base nesse contexto, calcula seu impacto. Finalmente, gera diferentes saídas de acordo com suas necessidades.
Alguns casos de uso do MetaHub incluem:
MetaHub usa arquivos de configuração que permitem personalizar alguns comportamentos de verificação, filtros padrão e muito mais. Os arquivos de configuração estão localizados em lib/config/.
Coisas que você pode personalizar:
lib/config/configuration.py: Este arquivo contém a configuração padrão do MetaHub. Você pode alterar os filtros padrão, os modos de saída padrão, as definições de ambiente e muito mais.
lib/config/impact.py: Este arquivo contém os valores e seus pesos para a fórmula de critério de impacto. Você pode modificar os valores e os pesos de acordo com suas necessidades.
lib/config/reources.py: Este arquivo contém definições para cada tipo de recurso, como quais eventos do CloudTrail procurar.
MetaHub é um programa Python3. Você precisa ter Python3 instalado em seu sistema e os módulos Python necessários descritos no arquivo requirements.txt.
Os requisitos podem ser instalados em seu sistema manualmente (usando pip3) ou usando um ambiente virtual Python (método sugerido).
git clone [email protected]:gabrielsoltz/metahub.gitcd metahubpython3 -m venv venv/metahubsource venv/metahub/bin/activatepip3 install -r requirements.txt./metahub -hdeactivateDa próxima vez, você só precisará dos passos 4 e 6 para usar o programa.
Alternativamente, você pode executar esta ferramenta usando Docker.
O MetaHub também está disponível como uma imagem Docker. Você pode executá-lo diretamente da imagem Docker pública ou construí-lo localmente.
As tags disponíveis para contêineres MetaHub são as seguintes:
latest: sincronizado com o branch master<x.y.z>: você encontra os lançamentos aquistable: esta tag sempre aponta para o lançamento mais recente.Para executar a partir do registro público, você pode executar o seguinte comando:```sh docker run -ti public.ecr.aws/n2p8q5p4/metahub:latest ./metahub -h
## Credenciais AWS e Docker
Se você já estiver logado na máquina host da AWS, pode usar as mesmas credenciais perfeitamente dentro de um contêiner Docker. Você pode conseguir isso passando as variáveis de ambiente necessárias para o contêiner ou montando o arquivo de credenciais.
Por exemplo, você pode executar o seguinte comando:```sh
docker run -e AWS_DEFAULT_REGION -e AWS_ACCESS_KEY_ID -e AWS_SECRET_ACCESS_KEY -e AWS_SESSION_TOKEN -ti public.ecr.aws/n2p8q5p4/metahub:latest ./metahub -h
Por outro lado, se você não estiver logado na máquina host, será necessário fazer login novamente a partir do próprio contêiner.
Ou você também pode construí-lo localmente:```sh git clone [email protected]:gabrielsoltz/metahub.git cd metahub docker build -t metahub . docker run -ti metahub ./metahub -h
# Executar com Lambda
**MetaHub** está pronto para Lambda/Serverless! Você pode executar o MetaHub diretamente em uma função AWS Lambda sem qualquer infraestrutura adicional necessária.
Executar o MetaHub em uma função Lambda permite automatizar sua execução com base em seus acionadores definidos. Por exemplo, você pode:
- Acionar a função Lambda do MetaHub cada vez que houver um novo achado de segurança para enriquecer esse achado de volta no AWS Security Hub.
- Acionar a função Lambda do MetaHub cada vez que houver um novo achado de segurança para supressão com base no Contexto.
- Acionar a função Lambda do MetaHub para identificar o proprietário afetado de um achado de segurança com base no Contexto e atribuí-lo usando seus sistemas internos.
- Acionar a função Lambda do MetaHub para criar um ticket com contexto enriquecido.
## Implantando Lambda
O código terraform para implantar a função Lambda está disponível na pasta `terraform/`.
Basta executar os seguintes comandos:```sh
cd terraform
terraform init
terraform apply
O código criará um arquivo zip para o código Lambda e um arquivo zip para as dependências Python que usaremos como camada Lambda. Ele também criará a função Lambda e todos os recursos necessários.
O código Terraform também criará uma ação personalizada do Security Hub e uma regra do EventBridge para acionar a função Lambda quando a ação personalizada for executada. Veja abaixo.
Você pode personalizar as opções do MetaHub para sua Lambda editando o arquivo lib/lambda.py. Você pode alterar as opções padrão do MetaHub, como os filtros, as opções Meta* e muito mais.
O Terraform criará as permissões mínimas necessárias para que a função Lambda seja executada localmente (na mesma conta). Se você quiser que sua Lambda assuma uma função em outras contas (por exemplo, precisará disso se estiver executando a Lambda na conta principal do Security Hub que está agregando descobertas de outras contas), precisará especificar a função a ser assumida, adicionando a opção --mh-assume-role na configuração da função Lambda (consulte a etapa anterior) e adicionando a política correspondente para permitir que a Lambda assuma essa função na função Lambda.
MetaHub pode ser executado como uma Ação Personalizada do Security Hub. Isso permite que você execute o MetaHub diretamente do console do Security Hub para uma descoberta selecionada ou para um conjunto selecionado de descobertas.
A ação personalizada acionará então uma função Lambda que executará o MetaHub para as descobertas selecionadas.
Quando você aciona a Lambda usando a Ação Personalizada do Security Hub, a Lambda lerá as descobertas selecionadas para seu contexto e executará uma vez para cada descoberta. Por padrão, nenhuma ação será tomada nas descobertas, mas você pode alterar esse comportamento. Veja Personalizar o comportamento do Lambda.
A ação personalizada do Security Hub é implantada como parte do código Terraform. Veja Implantando Lambda para mais informações.
Certifique-se de ter as credenciais AWS configuradas em sua máquina local (ou de onde você executará o MetaHub).
Por exemplo, você pode usar a opção aws configure.```sh
aws configure
Ou você pode exportar suas credenciais para o ambiente.```sh
export AWS_DEFAULT_REGION="us-east-1"
export AWS_ACCESS_KEY_ID= "ASXXXXXXX"
export AWS_SECRET_ACCESS_KEY= "XXXXXXXXX"
export AWS_SESSION_TOKEN= "XXXXXXXXX"
Se você estiver executando o MetaHub para uma configuração de conta única da AWS (o AWS Security Hub não está agregando descobertas de contas diferentes), não é necessário usar opções adicionais; o MetaHub usará as credenciais do seu ambiente. Ainda assim, se o design do seu IAM exigir, é possível fazer login e assumir uma função na mesma conta em que você está logado. Basta usar as opções --sh-assume-role para especificar a função e --sh-account com o mesmo ID da conta AWS onde você está logado.
--sh-region: A região da AWS onde o Security Hub está em execução. Se você não especificar uma região, ele usará a configurada no seu ambiente. Se estiver usando a agregação entre regiões do AWS Security Hub, você deve usar essa região como a opção --sh-region para buscar todas as descobertas juntas.
--sh-account e --sh-assume-role: O ID da conta AWS onde o Security Hub está em execução e a função IAM da AWS a ser assumida nessa conta. Essas opções são úteis quando você está logado em uma conta AWS diferente daquela onde o AWS Security Hub está em execução ou ao executar o AWS Security Hub em uma configuração de múltiplas contas AWS. Ambas as opções devem ser usadas juntas. A função fornecida precisa ter políticas suficientes para obter e atualizar descobertas no AWS Security Hub (se necessário). Se você não especificar um --sh-account, o MetaHub assumirá a conta na qual você está logado.
--sh-profile: Você também pode fornecer o nome do seu perfil AWS para usar no AWS Security Hub. Ao usar esta opção, você não precisa especificar --sh-account ou , pois o MetaHub usará as credenciais do perfil. Se você estiver usando e , essas opções terão precedência sobre .
Esta é a política IAM mínima necessária para ler e escrever no AWS Security Hub. Se você não quiser atualizar suas descobertas com o MetaHub, pode remover a ação securityhub:BatchUpdateFindings.```sh
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"security hub:GetFindings",
"security hub:ListFindingAggregators",
"security hub:BatchUpdateFindings",
"iam:ListAccountAliases"
],
"Resource": [
"*"
]
}
]
}
# Configurando Contexto
Se você estiver executando o MetaHub para uma configuração de múltiplas contas AWS (o AWS Security Hub está agregando descobertas de várias contas AWS), você deve fornecer a função a ser assumida para consultas de contexto, porque os recursos afetados não estão na mesma conta AWS que as descobertas do AWS Security Hub. O `--mh-assume-role` será usado para conectar-se diretamente aos recursos afetados na conta afetada. Esta função precisa ter políticas suficientes para ser capaz de descrever recursos.
## Política IAM para Contexto
A política mínima necessária para contexto inclui a política gerenciada `arn:aws:iam::aws:policy/SecurityAudit` e as seguintes ações:
- `tag:GetResources`
- `lambda:GetFunction`
- `lambda:GetFunctionUrlConfig`
- `cloudtrail:LookupEvents`
- `account:GetAlternateContact`
- `organizations:DescribeAccount`
- `iam:ListAccountAliases`
# Entradas
O MetaHub pode ler descobertas de segurança diretamente do AWS Security Hub usando sua API. Se você não usa o Security Hub, pode usar qualquer scanner compatível com ASFF. A maioria dos scanners de segurança em nuvem suporta o formato ASFF, como Prolwer, Steampipe, Trivy e outros.
Se você quiser ler de um arquivo ASFF de entrada, você precisa usar a opção (`--inputs file-asff`) e fornecer o caminho para o arquivo. Você pode fornecer vários arquivos separados por um espaço.:```sh
./metahub.py --inputs file-asff --input-asff path/to/the/file.json.asff path/to/the/file2.json.asff
Você também pode combinar descobertas do AWS Security Hub com arquivos ASFF de entrada especificando ambas as entradas (--inputs file-asff securityhub). O MetaHub processará todas as descobertas juntas e resultará em uma única saída.:```sh
./metahub.py --inputs file-asff securityhub --input-asff path/to/the/file.json.asff
Ao usar um arquivo como entrada, você não pode usar a opção `--sh-filters` para filtrar descobertas, pois esta opção depende da API da AWS para filtragem. Você não pode usar as opções `--update-findings` ou `--enrich-findings`, pois essas descobertas não estão no AWS Security Hub. Se você estiver lendo de ambas as fontes ao mesmo tempo, apenas as descobertas do AWS Security Hub serão atualizadas.
O MetaHub também implementa alguns **mecanismos de correção** para o formato ASFF, quando eles não estão formatados corretamente. Esta é uma abordagem de melhor esforço para tornar o ASFF o mais útil possível, mas não é perfeita e precisa ser corrigida no scanner de origem.
- Se a chave `Region` estiver ausente nos Recursos e no Nível Raiz, o MetaHub calculará a região com base no ARN do recurso afetado.
- Se o arquivo ASFF não estiver configurando corretamente o Tipo de Recurso ASFF, o MetaHub o calculará com base no ARN do recurso afetado usando a biblioteca [aws-arn](https://github.com/gabrielsoltz/aws-arn)
- Se algum outro campo estiver ausente, como `SeverityLabel`, `Workflow`, `RecordState`, `Compliance`, `Id`, `ProductArn` ou `StandardsControlArn`, o MetaHub os definirá como `Unknown`.
# Saídas
O **MetaHub** pode gerar diferentes saídas programáticas e visuais. Por padrão, todos os modos de saída estão habilitados: `json-short`, `json-full`, `json-statistics`, `json-inventory`, `html`, `csv` e `xlsx`. Se você quiser gerar apenas um modo de saída específico, pode usar a opção `--output-modes` com o modo de saída desejado. As saídas serão salvas na pasta `outputs/` com a data de execução.
Por exemplo, se você quiser gerar apenas a saída `json-short`, pode usar:```sh
./metahub.py --output-modes json-short
Se você quiser gerar saídas json-short, json-full e html, você pode usar:```sh
./metahub.py --output-modes json-short json-full html
**MetaHub** organiza todas as descobertas de segurança que afetam o mesmo recurso sob a chave `findings` na tentativa de evitar Shadowing (quando duas verificações se referem ao mesmo problema, mas uma de forma mais genérica que a outra) e Duplicação (quando você usa mais de um scanner e obtém o mesmo problema de mais de um). Você pode ver esse comportamento claramente nas saídas `json-short`, `json-full` e `html`.
- [JSON](#json)
- [HTML](#html)
- [CSV](#csv)
- [XLSX](#xlsx)
- [SQLite](#sqlite)
## JSON
> :info: Para explorar uma saída JSON interativamente, você pode usar a ferramenta [fx](https://github.com/antonmedv/fx).
### JSON-Full
Mostra o recurso afetado usando seu ARN como chave e as descobertas que o afetam como uma lista sob a chave `findings`. Além das descobertas, você também obterá as seguintes chaves: `ResourceType`, `Region`, `AwsAccountId`, `associations`, `config`, `tags`, `account`, `cloudtrail` e `impact`.```json
"arn:aws:ec2:eu-west-1:1234567890:instance/i-0a40b2be25dbac0ac": { --> The affected resource ARN
"findings": [ --> The findings affecting the resource
{
"EC2 instances should use Instance Metadata Service Version 2 (IMDSv2)": { --> The finding title
"SeverityLabel": "HIGH", --> The finding severity label
"Workflow":{ --> The finding workflow
"Status": "NEW",
},
"RecordState": "ACTIVE", --> The finding record state
"Compliance":{ --> The finding compliance
"Status": "FAILED",
},
"Id": "arn:aws:securityhub:eu-west-1:123456789012:security-control/EC2.8/finding/a1d4f19f-453e-4c3c-b486-8443c73e84f1",
"ProductArn": "arn:aws:securityhub:eu-west-1::product/aws/securityhub",
}
},
{"EC2 instances should be managed by AWS Systems Manager": {...}}, --> Another finding title
{"EC2 instances should not have a public IPv4 address": {...}} --> Another finding title
],
"ResourceType": "AwsEc2Instance", --> The affected resource type
"Region": "eu-west-1", --> The affected resource region
"AwsAccountId": "1234567890", --> The affected resource account id
"associations": { --> The associations of the affected resource
"security_groups": {}, --> The security groups associated with the affected resource
"iam_roles": {}, --> The IAM roles associated with the affected resource
"volumes": {}, --> The volumes associated with the affected resource
"autoscaling_groups": {}, --> The autoscaling groups associated with the affected resource
"vpcs": {}, --> The VPCs associated with the affected resource
"subnets": {}, --> The subnets associated with the affected resource
},
"config": { --> The configuration of the affected resource (based on it's type)
"public_ip": "200.200.200.200", --> The public IP of the affected resource, if any
"private_ip": "10.10.10.10", --> The private IP of the affected resource, if any
"key": "ssh-key", --> The key used for the affected resource, if any
"metadata_options": { --> The metadata options of the affected resource, if any
"State": "applied",
"HttpTokens": "required",
"HttpPutResponseHopLimit": 1,
"HttpEndpoint": "enabled",
"HttpProtocolIpv6": "disabled",
"InstanceMetadataTags": "disabled"
},
},
"tags": { --> The tags of the affected resource
"Name": "test", --> The tag key and value
"Env": "prod",
"awsApplication": "arn:aws:resource-groups:eu-west-1:1234567890:group/app1/0c8vpbjkzeeffsz2cqgxpae7b2"
},
"account": { --> The account of the affected resource
"Alias": "prod", --> The account alias
"AlternateContact": {}, --> The alternate contact of the account, if any
"Organizations": { --> The organization of the account, if any
"Id": "o-1234567890",
"Arn": "arn:aws:organizations::1234567890:organization/o-1234567890/o-1234567890",
"MasterAccountId": "1234567890",
"MasterAccountArn": "arn:aws:organizations::1234567890:account/o-1234567890/1234567890",
"MasterAccountEmail": "",
"Details": {
"ParentId": "p-k1234567890",
"ParentType": "ROOT",
"OU": "ROOT",
"Policies": { --> The policies of the account, if any
"p-FullAWSAccess": {...} --> The policy name and policy
}
}
},
},
"cloudtrail": { --> The CloudTrail events affecting the affected resource
"RunInstances": { --> The CloudTrail event name
"Username": "test", --> The username of the event, if any
"EventTime": "2021-01-01T00:00:00Z",
"EventId": "12345678-1234-1234-1234-123456789012",
}
},
"impact": { --> The impact of the affected resource
"exposure": {...}, --> The exposure impact
"access": {...}, --> The access impact
"encryption": {...}, --> The encryption impact
"status": {...}, --> The status impact
"environment": {...}, --> The environment impact
"application": {...}, --> The application impact
"owner": {...}, --> The owner impact
"findings": {...}, --> The findings impact
"score": {...} --> The total impact score
}
}
Mostra o recurso afetado usando seu ARN como chave e as descobertas que o afetam como uma lista sob a chave findings. Além das descobertas, você também obterá as seguintes chaves: ResourceType, Region, AwsAccountId, associations, config, tags, account, cloudtrail, e impact.```json
"arn:aws:ec2:eu-west-1:1234567890:instance/i-0a40b2be25dbac0ac": { --> The affected resource ARN
"findings": [ --> The findings affecting the resource
"EC2 instances should use Instance Metadata Service Version 2 (IMDSv2)", --> The finding title
"EC2 instances should be managed by AWS Systems Manager", --> The finding title
"EC2 instances should not have a public IPv4 address" --> The finding title
],
"ResourceType": "AwsEc2Instance", --> The affected resource type
"Region": "eu-west-1", --> The affected resource region
"AwsAccountId": "1234567890", --> The affected resource account id
"associations": { --> The associations of the affected resource
"security_groups": {}, --> The security groups associated with the affected resource
"iam_roles": {}, --> The IAM roles associated with the affected resource
"volumes": {}, --> The volumes associated with the affected resource
"autoscaling_groups": {}, --> The autoscaling groups associated with the affected resource
"vpcs": {}, --> The VPCs associated with the affected resource
"subnets": {}, --> The subnets associated with the affected resource
},
"config": { --> The configuration of the affected resource (based on it's type)
"public_ip": "200.200.200.200", --> The public IP of the affected resource, if any
"private_ip": "10.10.10.10", --> The private IP of the affected resource, if any
"key": "ssh-key", --> The key used for the affected resource, if any
"metadata_options": { --> The metadata options of the affected resource, if any
"State": "applied",
"HttpTokens": "required",
"HttpPutResponseHopLimit": 1,
"HttpEndpoint": "enabled",
"HttpProtocolIpv6": "disabled",
"InstanceMetadataTags": "disabled"
},
},
"tags": { --> The tags of the affected resource
"Name": "test", --> The tag key and value
"Env": "prod",
"awsApplication": "arn:aws:resource-groups:eu-west-1:1234567890:group/app1/0c8vpbjkzeeffsz2cqgxpae7b2"
},
"account": { --> The account of the affected resource
"Alias": "prod", --> The account alias
"AlternateContact": {}, --> The alternate contact of the account, if any
"Organizations": { --> The organization of the account, if any
"Id": "o-1234567890",
"Arn": "arn:aws:organizations::1234567890:organization/o-1234567890/o-1234567890",
"MasterAccountId": "1234567890",
"MasterAccountArn": "arn:aws:organizations::1234567890:account/o-1234567890/1234567890",
"MasterAccountEmail": "",
"Details": {
"ParentId": "p-k1234567890",
"ParentType": "ROOT",
"OU": "ROOT",
"Policies": { --> The policies of the account, if any
"p-FullAWSAccess": {...} --> The policy name and policy
}
}
},
},
"cloudtrail": { --> The CloudTrail events affecting the affected resource
"RunInstances": { --> The CloudTrail event name
"Username": "test", --> The username of the event, if any
"EventTime": "2021-01-01T00:00:00Z",
"EventId": "12345678-1234-1234-1234-123456789012",
}
},
"impact": { --> The impact of the affected resource
"exposure": {...}, --> The exposure impact
"access": {...}, --> The access impact
"encryption": {...}, --> The encryption impact
"status": {...}, --> The status impact
"environment": {...}, --> The environment impact
"application": {...}, --> The application impact
"owner": {...}, --> The owner impact
"findings": {...}, --> The findings impact
"score": {...} --> The total impact score
}
}
### JSON-Inventory
Mostrar uma lista de todos os recursos com seus ARNs.```json
[
"arn:aws:sagemaker:us-east-1:ofuscated:notebook-instance/obfuscated",
"arn:aws:sagemaker:eu-west-1:ofuscated:notebook-instance/obfuscated"
]
Mostra estatísticas para cada campo/valor. Na saída, você verá cada campo/valor e o número de ocorrências; por exemplo, a seguinte saída mostra estatísticas para seis descobertas.```json { "Title": { "SageMaker.1 Amazon SageMaker notebook instances should not have direct internet access": 2, "SageMaker.2 SageMaker notebook instances should be launched in a custom VPC": 2, "SageMaker.3 Users should not have root access to SageMaker notebook instances": 2 }, "SeverityLabel": { "HIGH": 6 }, "Workflow": { "NEW": 6 }, "RecordState": { "ACTIVE": 6 }, "Compliance": { "FAILED": 6 }, "ProductArn": { "arn:aws:security hub:eu-west-1::product/aws/security hub": 3, "arn:aws:security hub:us-east-1::product/aws/security hub": 3 }, "ResourceType": { "AwsSageMakerNotebookInstance": 6 }, "AwsAccountId": { "obfuscated": 6 }, "Region": { "eu-west-1": 3, "us-east-1": 3 }, "ResourceId": { "arn:aws:sagemaker:eu-west-1:ofuscated:notebook-instance/obfuscated": 3, "arn:aws:sagemaker:us-east-1:ofuscated:notebook-instance/obfuscated": 3 } }
## HTML
Você pode criar relatórios HTML ricos das suas descobertas, adicionando seu contexto como parte deles.
Relatórios HTML são interativos de várias maneiras:
- Você pode adicionar/remover colunas.
- Você pode classificar e filtrar por qualquer coluna.
- Você pode auto-filtrar por qualquer coluna.
- Você pode agrupar/desagrupar descobertas.
- Você também pode baixar esses dados para xlsx, CSV, HTML e JSON.
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/6190/21d785d2413698ed7cb3e9dc7e9b51dc6550395a598d777abc9fc358f8a23573.png" alt="html-example"/>
</p>
## CSV
Você pode criar relatórios CSV das suas descobertas, adicionando seu contexto como parte deles.
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/6190/66f15350123702e1cc317e47938401853bdcb1d86dad0ad4e48e73f15e00dd76.png" alt="csv-example"/>
</p>
## XLSX
Semelhante ao CSV, mas com mais opções de formatação.
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/6190/953a77917dc5b06e5185e6cb882ba7e711d785861e184599f10cd472efc42db9.png" alt="xlsx-example"/>
</p>
## Personalizar saídas HTML, CSV ou XLSX
Você pode personalizar quais chaves de contexto serão desdobradas como colunas para suas saídas HTML, CSV e XLSX usando as opções `--output-tag-columns` e `--output-config-columns` (como uma lista de colunas). Se as chaves que você especificou não existirem para o recurso afetado, elas ficarão vazias. Você também pode configurar essas colunas por padrão no arquivo de configuração (Veja [Personalizando a Configuração](#customizing-configuration)).
Por exemplo, você pode gerar uma saída HTML com Tags e adicionar "Owner" e "Environment" como colunas ao seu relatório usando:```sh
./metahub --output-modes html --output-tag-columns Owner Environment
MetaHub pode salvar os achados e o contexto em um banco de dados SQLite. Este banco de dados pode ser usado para análises adicionais, relatórios e integração com outras ferramentas, como Powerpipe. O banco de dados será salvo na pasta outputs/ com a data de execução e a extensão .db.
Você pode usar o banco de dados SQLite gerado pelo MetaHub com o Powerpipe. Você pode encontrar o mod MetaHub PowerPipe na pasta powerpipe/.
Para usá-lo, você precisa ter o Powerpipe instalado em seu sistema.
Depois de instalado, você pode executar o seguinte comando:```sh powerpipe server --database sqlite:../outputs/metahub-20240331-182942.db
### Crie seus próprios painéis
Criar painéis com Powerpipe é super fácil e poderoso. Você pode consultar a [documentação do Powerpipe](https://powerpipe.io/docs) para mais informações.
Abaixo você encontrará as tabelas disponíveis no banco de dados SQLite.
#### Resources
| Column Name | Data Type | Description |
| ------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
| resource_arn | VARCHAR | O Nome do Recurso da Amazon (ARN) do recurso, servindo como chave primária. |
| resource_type | VARCHAR | O tipo do recurso. |
| resource_region | VARCHAR | A região onde o recurso está localizado. |
| resource_account_id | VARCHAR | O ID da conta associada ao recurso. Chave estrangeira que referencia accounts(account_id). |
| resource_account_alias | VARCHAR | O alias da conta associada ao recurso. |
| resource_tags | TEXT | Tags associadas ao recurso. |
| resource_exposure | VARCHAR | O nível de exposição do recurso. |
| resource_access | VARCHAR | O nível de acesso do recurso. |
| resource_encryption | VARCHAR | O status de criptografia do recurso. |
| resource_status | VARCHAR | O status atual do recurso. |
| resource_application | VARCHAR | A aplicação associada ao recurso. |
| resource_environment | VARCHAR | O ambiente (ex.: produção, staging) em que o recurso está. |
| resource_owner | VARCHAR | O proprietário do recurso. |
| resource_score | INTEGER | Uma pontuação associada ao recurso. |
| resource_findings_score | INTEGER | Uma pontuação baseada em descobertas associadas ao recurso. |
| resource_findings_critical | INTEGER | O número de descobertas críticas. |
| resource_findings_high | INTEGER | O número de descobertas de alta gravidade. |
| resource_findings_medium | INTEGER | O número de descobertas de gravidade média. |
| resource_findings_low | INTEGER | O número de descobertas de baixa gravidade. |
| resource_findings_informational | INTEGER | O número de descobertas informativas. |
#### Findings
| Column Name | Data Type | Description |
| ------------------------ | --------- | ------------------------------------------------------------------ |
| finding_id | VARCHAR | O identificador único da descoberta, servindo como chave primária. |
| finding_title | VARCHAR | O título da descoberta. |
| finding_severity | VARCHAR | A gravidade da descoberta. |
| finding_workflowstatus | VARCHAR | O status do fluxo de trabalho da descoberta. |
| finding_recordstate | VARCHAR | O estado do registro da descoberta. |
| finding_compliancestatus | VARCHAR | O status de conformidade da descoberta. |
| finding_productarn | VARCHAR | O ARN do produto que gera a descoberta. |
| finding_resource_arn | VARCHAR | O ARN do recurso associado. |
#### Accounts
| Column Name | Data Type | Description |
| ------------------------------- | --------- | ----------------------------------------------------------------------------- |
| account_id | INTEGER | O identificador único da conta, servindo como chave primária. |
| account_alias | VARCHAR | O alias da conta. |
| account_organizations_id | VARCHAR | O ID da organização à qual a conta pertence. |
| account_organizations_arn | VARCHAR | O ARN da organização à qual a conta pertence. |
| account_master_account_id | VARCHAR | O ID da conta mestre, se esta conta fizer parte de uma AWS Organization. |
| account_master_account_email | VARCHAR | O endereço de email associado à conta mestre. |
| account_alternate_contact_type | VARCHAR | O tipo de contato alternativo (ex.: cobrança, segurança). |
| account_alternate_contact_name | VARCHAR | O nome do contato alternativo. |
| account_alternate_contact_email | VARCHAR | O endereço de email do contato alternativo. |
| account_alternate_contact_phone | VARCHAR | O número de telefone do contato alternativo. |
| account_alternate_contact_title | VARCHAR | O título do contato alternativo. |
# Filtros
Você pode filtrar as descobertas de segurança e os recursos que obtém de sua fonte de diferentes maneiras e combinar todos eles para obter exatamente o que procura, e depois reutilizar esses filtros para criar automações, alertas, relatórios e muito mais.
- [Filtragem do Security Hub](#security-hub-filtering)
- [Filtragem do Security Hub usando templates YAML](#security-hub-filtering-using-yaml-templates)
- [Filtros do Config](#config-filters)
- [Filtros de Tags](#tags-filters)
- [Filtros de Impacto](#impact-filters)
## Filtragem do Security Hub
O MetaHub suporta a filtragem de descobertas do AWS Security Hub no formato `KEY=VALUE` para o AWS Security Hub usando a opção `--sh-filters`, da mesma forma que você filtraria usando a AWS CLI, mas limitado à comparação `EQUALS`. Se desejar outra comparação, use a opção `--sh-template` [Filtragem do Security Hub usando templates YAML](#security-hub-filtering-using-yaml-templates).
Você pode verificar os filtros disponíveis na [Documentação da AWS](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/securityhub.html#SecurityHub.Client.get_findings)```sh
./metahub --sh-filters <KEY=VALUE>
Se você não especificar nenhum filtro, os filtros padrão são aplicados: RecordState=ACTIVE WorkflowStatus=NEW
Passar filtros usando esta opção redefine os filtros padrão. Se quiser adicionar filtros aos padrões, você precisa especificá-los além dos padrões. Por exemplo, adicionando SeverityLabel aos filtros padrão:```sh ./metahub --sh-filters RecordState=ACTIVE WorkflowStatus=NEW
Se um valor contiver espaços, você deve especificá-lo usando aspas duplas: `"ProductName="Security Hub"`
Você pode adicionar quantos filtros diferentes precisar à sua consulta e também adicionar a mesma chave de filtro com valores diferentes:
Exemplos:
- Filtrar por Severity (CRITICAL):```sh
./metaHub --sh-filters RecordState=ACTIVE WorkflowStatus=NEW SeverityLabel=CRITICAL
- Filtrar por Gravidade e Conta AWS:```sh
./metaHub --sh-filters RecordState=ACTIVE WorkflowStatus=NEW SeverityLabel=CRITICAL AwsAccountId=1234567890
- Filtrar por Tipo de Recurso AWS:```sh
./metahub --sh-filters RecordState=ACTIVE WorkflowStatus=NEW ResourceType=AwsEc2SecurityGroup
- Filtrar por Finding Id:```sh
./metahub --sh-filters Id="arn:aws:security hub:eu-west-1:01234567890:subscription/aws-foundational-security-best-practices/v/1.0.0/EC2.19/finding/01234567890-1234-1234-1234-01234567890"
Filtrar por Status de Conformidade:```sh ./metahub --sh-filters ComplianceStatus=FAILED
## Filtragem do Security Hub usando templates YAML
**MetaHub** permite que você crie filtros complexos usando arquivos YAML (templates) que podem ser reutilizados quando necessário. Os templates YAML permitem escrever filtros usando qualquer comparação suportada pelo AWS Security Hub, como "EQUALS' | 'PREFIX' | 'NOT_EQUALS' | 'PREFIX_NOT_EQUALS". Você pode chamar seu arquivo YAML usando a opção `--sh-template <<FILE>>`.
Você pode encontrar exemplos na pasta [templates](https://github.com/gabrielsoltz/metahub/blob/HEAD/templates)
- Filtrar usando o template YAML default.yml:```sh
./metaHub --sh-template templates/default.yml
MetaHub suporta Config filters (e associações) usando KEY=VALUE onde o valor só pode ser True ou False com a opção --mh-filters-config. Você pode usar quantos filtros quiser e separá-los por espaços. Se especificar mais de um filtro, obterá todos os recursos que correspondem a todos os filtros.
Config filters suportam apenas valores True ou False:
True ou com dados.False ou sem dados.Config filters são executados após os filtros do AWS Security Hub:
--sh-filters (ou os padrões).--mh-filters-config, portanto é um subconjunto dos recursos do ponto 1.Exemplos:
ResourceType=AwsEc2SecurityGroup) com achados do AWS Security Hub que estejam ACTIVE e NEW (RecordState=ACTIVE WorkflowStatus=NEW) apenas se estiverem associados a Network Interfaces (network_interfaces=True):```sh
./metahub --sh-filters RecordState=ACTIVE WorkflowStatus=NEW ResourceType=AwsEc2SecurityGroup --mh-filters-config network_interfaces=True- Obter todos os buckets S3 (`ResourceType=AwsS3Bucket`) apenas se forem públicos (`public=True`):```sh
./metahub --sh-filters ResourceType=AwsS3Bucket --mh-filters-config public=False
MetaHub suporta filtros de tags no formato KEY=VALUE, onde KEY é o nome da tag e VALUE é o valor da tag. Você pode usar quantos filtros desejar e separá-los por espaços. Especificar vários filtros retornará todos os recursos que correspondem a pelo menos um filtro.
Os filtros de tags são executados após os filtros do AWS Security Hub:
--sh-filters (ou os padrões).--mh-filters-tags, ou seja, um subconjunto dos recursos do ponto 1.Exemplos:
ResourceType=AwsEc2SecurityGroup) com descobertas do AWS Security Hub que estão ACTIVE e NEW (RecordState=ACTIVE WorkflowStatus=NEW) apenas se estiverem marcados com uma tag Environment e valor Production:```sh
./metahub --sh-filters RecordState=ACTIVE WorkflowStatus=NEW ResourceType=AwsEc2SecurityGroup --mh-filters-tags Environment=Production## Filtros de Impacto
**MetaHub** suporta **filtros de impacto**, você pode filtrar pelas [chaves de impacto](#impact) calculadas pelo MetaHub. Você pode usar quantos filtros quiser e separá-los usando espaços. Se especificar mais de um filtro, você obterá todos os recursos que correspondem a **todos** os filtros.
Exemplos:
- Filtre todos os Security Findings que afetam recursos com exposição calculada como effectively-public:```sh
./metahub --mh-filters-impact exposure=effectively-public
# Security Hub Actions
## Atualizando o Status do Workflow
Você pode usar **MetaHub** para atualizar o status do workflow dos achados (findings) do AWS Security Hub (`NOTIFIED,` `NEW,` `RESOLVED,` `SUPPRESSED`) com um único comando. Você usará a opção `--update-findings` para atualizar todos os achados da sua consulta do MetaHub. Isso significa que você pode atualizar um, dez ou milhares de achados usando apenas um comando. A API do AWS Security Hub está limitada a 100 achados por atualização. O Metahub dividirá seus resultados em blocos de 100 itens para evitar essa limitação e atualizar seus achados independentemente da quantidade.
Por exemplo, usando o seguinte filtro: `./metahub --sh-filters ResourceType=AwsSageMakerNotebookInstance RecordState=ACTIVE WorkflowStatus=NEW` encontrei dois recursos afetados com três achados cada, totalizando seis achados do Security Hub.
Executar o seguinte comando de atualização atualizará o status do workflow desses seis achados para `NOTIFIED` com uma Nota:```sh
./metahub --update-findings Workflow=NOTIFIED Note="Enter your ticket ID or reason here as a note that you will add to the finding as part of this update."
A opção --update-findings solicitará sua confirmação antes de atualizar suas descobertas. Você pode pular essa confirmação usando a opção --no-actions-confirmation.
Você pode usar MetaHub para enriquecer suas descobertas do AWS Security Hub com saídas de Contexto usando a opção --enrich-findings. Enriquecer suas descobertas significa atualizá-las diretamente no AWS Security Hub. MetaHub usa o campo UserDefinedFields para isso.
Ao enriquecer suas descobertas diretamente no AWS Security Hub, você pode aproveitar recursos como Insights e Filtros usando as informações extras que não estavam disponíveis anteriormente no Security Hub.
Por exemplo, você deseja enriquecer todas as descobertas do AWS Security Hub com WorkflowStatus=NEW, RecordState=ACTIVE e ResourceType=AwsS3Bucket que são public=True com saídas de Contexto:```sh
./metahub --sh-filters RecordState=ACTIVE WorkflowStatus=NEW ResourceType=AwsS3Bucket --mh-filters-checks public=True --enrich-findings
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/6190/93a45d119a712b11ae5f23ea68e3a1f7d71e0e9511df7d7dadd2b462fcde71a2.png" alt="update-findings" width="850"/>
</p>
O `--enrich-findings` pedirá confirmação antes de enriquecer seus achados. Você pode pular essa confirmação usando a opção `--no-actions-confirmation`.
# Contribuindo
Você pode seguir este guia se quiser contribuir para o módulo Context [guia](https://github.com/gabrielsoltz/metahub/blob/HEAD/docs/context.md).
| Status Possíveis | Valor | Descrição |
|---|
| 🔴 effectively-public | 100% | O recurso é efetivamente público a partir da Internet. |
| 🟠 restricted-public | 40% | O recurso é público, mas há uma restrição como um Grupo de Segurança. |
| 🟠 unrestricted-private | 30% | O recurso é privado, mas sem restrições, como um grupo de segurança aberto. |
| 🟠 launch-public | 10% | São recursos que podem lançar outros recursos como públicos. Por exemplo, um grupo Auto Scaling ou uma Sub-rede. |
| 🟢 restricted | 0% | O recurso está restrito. |
| 🔵 unknown | - | O recurso não pôde ser verificado. |
| Status Possíveis | Valor | Descrição |
|---|
| 🔴 irrestrito | 100% | O principal é irrestrito, sem qualquer condição ou restrição. |
| 🔴 principal-não-confiável | 70% | O principal é uma conta AWS, que não faz parte das suas contas confiáveis. |
| 🟠 principal-irrestrito | 40% | O principal não é restrito, definido com um curinga. Podem existir condições restringindo-o ou outras restrições como s3 public blocks. |
| 🟠 principal-de-outra-conta | 30% | O principal é de outra conta AWS. |
| 🟠 ações-irrestritas | 30% | As ações são definidas usando curingas. |
| 🟠 ações-perigosas | 30% | Algumas ações perigosas são definidas como parte desta política. |
| 🟠 serviço-irrestrito | 10% | A política permite um serviço AWS como principal sem restrição. |
| 🟢 restrito | 0% | A política é restrita. |
| 🔵 desconhecido | - | A política não pôde ser verificada. |
| Descrição |
|---|
| 🔴 não criptografado | 100% | O recurso não está totalmente criptografado. |
| 🟢 criptografado | 0% | O recurso está totalmente criptografado, incluindo quaisquer de suas associações. |
| 🔵 desconhecido | - | A criptografia do recurso não pôde ser verificada. |
| Possíveis Status | Valor | Descrição |
|---|
| 🟠 anexado | 100% | O recurso suporta anexação e está anexado. |
| 🟠 em execução | 100% | O recurso suporta execução e está em execução. |
| 🟠 ativado | 100% | O recurso suporta ativação e está ativado. |
| 🟢 não anexado | 0% | O recurso suporta anexação e não está anexado. |
| 🟢 não em execução | 0% | O recurso suporta execução e não está em execução. |
| 🟢 não ativado | 0% | O recurso suporta ativação e não está ativado. |
| 🔵 desconhecido | - | O recurso não pôde ser verificado quanto ao status. |
| Status Possíveis | Valor | Descrição |
|---|
| 🟠 production | 100% | É um recurso de produção. |
| 🟢 staging | 30% | É um recurso de staging. |
| 🟢 development | 0% | É um recurso de desenvolvimento. |
| 🔵 unknown | - | Não foi possível verificar o ambiente para o recurso. |
--sh-assume-role--sh-account--sh-assume-role--sh-profile