Verificando IDs de AMIs da AWS no Terraform com Regula e Open Policy Agent

Na semana passada, anunciamos o Fugue IaC, que permite às equipes de engenharia de nuvem proteger a infraestrutura como código (IaC) e o ambiente de execução na nuvem usando as mesmas políticas. Para executar verificações de IaC localmente, a Fugue desenvolveu o Regula, uma ferramenta de código aberto criada com base no Open Policy Agent (OPA).

O Regula pode ser usado com ou sem o Fugue. Ele vem com centenas de regras prontas para verificar infraestrutura como código (IaC) em Terraform e CloudFormation, além de manifestos do Kubernetes. Essas regras são mapeadas para os CIS Benchmarks e abrangem muitas vulnerabilidades de segurança.

Mas às vezes há políticas específicas da organização que você quer aplicar — por exemplo, exigir que instâncias do Amazon EC2 usem AMIs aprovadas. Nesses casos, você pode escrever uma regra personalizada usando a linguagem Rego do OPA, e o Regula vai aplicá-la à sua IaC. Assim, se a sua IaC declarar uma AMI não aprovada, a verificação do Regula falhará.

Nesta publicação:

• Vamos escrever uma regra personalizada para verificar as AMIs do AWS EC2 declaradas no Terraform, explicando o código Rego linha por linha.

• Vamos usar nossa ferramenta de código aberto Regula para testar a regra com um arquivo Terraform em não conformidade.

• Vamos corrigir o Terraform em não conformidade.

Esta publicação usa o Regula para verificar HCL do Terraform, mas você também pode usar exatamente a mesma regra personalizada com o SaaS do Fugue para verificar recursos no ambiente de execução da nuvem. Isso é possível graças ao Unified Policy Engine do Fugue, que permite usar as mesmas regras na IaC e no ambiente de execução.

Você encontra todo o código neste gist do GitHub.

Vamos lá!

Primeiros passos

Baixe os arquivos de código

No nosso gist do GitHub, selecione o botão Download ZIP e extraia os arquivos. São dois arquivos:

• approved_ami.rego – uma regra personalizada escrita em Rego

• ami.tf – um arquivo HCL do Terraform que declara duas instâncias EC2: uma em conformidade e outra em não conformidade

Instale o Regula

O próximo passo é instalar o Regula, caso ainda não tenha feito isso. Se você usa o Homebrew, execute estes comandos no terminal:

brew tap fugue/regula
brew install regula

Como alternativa, você pode instalar um binário pré-compilado para sua plataforma ou, se preferir, executar o Regula com o Docker.

Como escrever a regra personalizada

Primeiro, vamos decidir que tipo de regra escrever. O Regula oferece dois tipos de regra: simples e avançada. As regras simples são úteis quando você verifica um único tipo de recurso. As regras avançadas são mais indicadas para lógicas complexas que envolvem vários recursos ou verificam a ausência de recursos.

Vamos verificar apenas um tipo de recurso do Terraform, aws_instance, então escreveremos uma regra simples.

Declaração de pacote

Vamos começar pelo básico. Todas as regras do Regula precisam ter uma declaração de pacote que comece com rules. e termine com um identificador curto (linha 4):

4package rules.approved_ami

Metadados

Podemos adicionar metadados opcionalmente (linhas 6 a 18):

6__rego__metadoc__ := {
7  "id": "CUSTOM_0002",
8  "title": "AWS EC2 instances must use approved AMIs",
9  "description": "Per company policy, EC2 instances may only use AMI IDs from a pre-approved list",
10  "custom": {
11    "controls": {
12      "CORPORATE-POLICY": [
13        "CORPORATE-POLICY_1.2"
14      ]
15    },
16    "severity": "High"
17  }
18}

Isso não é obrigatório, mas torna os relatórios do Regula ainda mais informativos.

Tipo de recurso

Em seguida, especificamos qual tipo de recurso do Terraform queremos verificar (linha 20):

20resource_type = "aws_instance"

Essa sintaxe indica que a entrada será uma única instância do AWS EC2. Quando o Regula aplicar a regra ao nosso Terraform, ele avaliará uma instância por vez.

Conjunto de AMIs aprovadas

Para simplificar, vamos supor que sua organização aprovou estes dois IDs de AMI:

• ami-09e67e426f25ce0d7

• ami-03d5c68bab01f3496

(Se tiver curiosidade, esses são os IDs do Ubuntu Server 20.04 LTS HVM, tipo de volume SSD, nas regiões us-east-1 e us-west-2, respectivamente.)

Agora, vamos criar um conjunto com os IDs das AMIs aprovadas. Vamos chamá-lo de approved_amis (linhas 22 a 26):

22approved_amis = {
23  # Ubuntu Server 20.04 LTS (HVM), SSD Volume Type
24  "ami-09e67e426f25ce0d7", # us-east-1
25  "ami-03d5c68bab01f3496" # us-west-2 
26}

A regra deny

Por fim, vamos escrever uma regra deny. É nela que fica a lógica principal! A regra deny define as condições em que um recurso deve falhar na verificação.

Vamos caprichar um pouco e retornar uma mensagem de erro personalizada que informa o ID da AMI não aprovada quando uma instância falha na verificação do Regula.

Nossa regra deny deve verificar se o ID da AMI da instância que está sendo avaliada pertence ao conjunto de AMIs aprovadas. Se não pertencer, deny deve retornar uma mensagem de erro para esse recurso (ou seja, gerar um resultado de regra com falha). deny é definido nas linhas 28 a 31:

28deny[msg] {
29  not approved_amis[input.ami]
30  msg = sprintf("%s is not an approved AMI ID", [input.ami])
31}

Vamos analisar a lógica mais de perto:

29not approved_amis[input.ami]

input.ami representa o atributo ami de cada instância EC2 no documento de entrada (seu arquivo HCL do Terraform — ou, mais especificamente, uma representação JSON dele, transformada pelo Regula nos bastidores).

not approved_amis[input.ami] será avaliado como true se o atributo ami da instância atual não pertencer ao conjunto.

Juntando tudo, a regra deny diz: “Se input.ami não estiver em approved_amis, a verificação do Regula deverá falhar e retornar uma mensagem de erro.”

Definimos a mensagem de erro nesta linha:

msg = sprintf("%s is not an approved AMI ID", [input.ami])

Aqui usamos a função integrada sprintf do Rego para exibir a ami do recurso que está sendo avaliado.

E essa é a nossa regra personalizada! Veja o código completo. Agora, vamos colocar o Regula à prova!

Executando a regra personalizada com o Regula

Agora, vamos testar a regra em um arquivo simples do Terraform. O HCL do Terraform no nosso gist do GitHub define duas instâncias EC2: uma instância “boa”, com o ID de AMI aprovado ami-09e67e426f25ce0d7, e uma instância “ruim”, com o ID de AMI nada suspeito ami-totallylegitamiid.

Execute o Regula

No terminal, use cd para acessar o diretório que contém os arquivos de código e execute este comando:

regula run ami.tf --include approved_ami.rego --user-only

Este comando executa nossa regra personalizada no arquivo Terraform. A flag --user-only indica que somente a regra personalizada deve ser aplicada; para esta publicação, não vamos usar a biblioteca de regras integradas do Regula. (Ainda assim, é recomendável usar as regras integradas, incluídas por padrão quando você executa regula run.)

O resultado é:

Como você pode ver, nosso arquivo Terraform falhou na regra com a mensagem ami-totallylegitamiid is not an approved AMI ID. Ótimo: isso significa que nossa regra personalizada funcionou! O Regula mostrou que a instância aws_instance.bad (linha 13, coluna 1) não tinha um ID de AMI aprovado.

Veja um relatório mais detalhado

Para ver mais detalhes, vamos conferir o relatório completo, formatado como JSON:

regula run ami.tf --include approved_ami.rego --user-only --format json

Aqui vemos o resultado completo, incluindo todos os resultados das regras. Observe abaixo que aws_instance.bad aparece novamente com resultado FAIL, enquanto aws_instance.good tem resultado PASS:

{
  "rule_results": [
    {
      "controls": [
        "CORPORATE-POLICY_1.2"
      ],
      "filepath": "ami.tf",
      "input_type": "tf",
      "provider": "aws",
      "resource_id": "aws_instance.bad",
      "resource_type": "aws_instance",
      "rule_description": "Per company policy, EC2 instances may only use AMI IDs from a pre-approved list",
      "rule_id": "CUSTOM_0002",
      "rule_message": "ami-totallylegitamiid is not an approved AMI ID",
      "rule_name": "approved_ami",
      "rule_result": "FAIL",
      "rule_severity": "High",
      "rule_summary": "AWS EC2 instances must use approved AMIs",
      "source_location": [
        {
          "path": "ami.tf",
          "line": 13,
          "column": 1
        }
      ]
    },
    {
      "controls": [
        "CORPORATE-POLICY_1.2"
      ],
      "filepath": "ami.tf",
      "input_type": "tf",
      "provider": "aws",
      "resource_id": "aws_instance.good",
      "resource_type": "aws_instance",
      "rule_description": "Per company policy, EC2 instances may only use AMI IDs from a pre-approved list",
      "rule_id": "CUSTOM_0002",
      "rule_message": "",
      "rule_name": "approved_ami",
      "rule_result": "PASS",
      "rule_severity": "High",
      "rule_summary": "AWS EC2 instances must use approved AMIs",
      "source_location": [
        {
          "path": "ami.tf",
          "line": 8,
          "column": 1
        }
      ]
    }
  ],
  "summary": {
    "filepaths": [
      "ami.tf"
    ],
    "rule_results": {
      "FAIL": 1,
      "PASS": 1,
      "WAIVED": 0
    },
    "severities": {
      "Critical": 0,
      "High": 1,
      "Informational": 0,
      "Low": 0,
      "Medium": 0,
      "Unknown": 0
    }
  }
}

Você também pode conferir os outros metadados que definimos anteriormente na regra.

Corrija o Terraform

Para deixar o Terraform em conformidade, edite ami.tf e substitua ami-totallylegitamiid por ami-09e67e426f25ce0d7. Em seguida, execute o Regula novamente. Desta vez, vamos usar o formato de texto padrão:

regula run ami.tf --include approved_ami.rego --user-only

E o resultado é:

No problems found.

Sucesso! Protegemos nossa IaC no Terraform usando apenas AMIs aprovadas, como comprova o Regula.

Para saber mais

Nesta publicação, escrevemos uma regra personalizada em Rego, usamos o Regula para verificá-la em um arquivo HCL do Terraform e deixamos o Terraform em conformidade.

Para saber mais sobre o Regula, acesse o site da documentação do Regula. Estes recursos também podem ser úteis:

• Como escrever regras

• Exemplo: como escrever uma regra simples

• Uso