Adicionando novas remediações

As correções podem ser adicionadas manualmente, atualizando os arquivos apropriados do manual, ou programaticamente, estendendo a solução por meio de construções de CDK, dependendo do fluxo de trabalho de sua preferência.

nota

As instruções a seguir utilizam os recursos instalados pela solução como ponto de partida. Por convenção, a maioria dos nomes de recursos da solução contém ASR and/or SO0111 para facilitar sua localização e identificação.

Visão geral do fluxo de trabalho manual

Os runbooks do Automated Security Response on AWS devem seguir a seguinte nomenclatura padrão:

ASR- <standard> - - <version> <control>

Padrão: a abreviatura do padrão de segurança. Isso deve corresponder aos padrões suportados pelo ASR. Deve ser “CIS”, “AFSBP”, “PCI”, “NIST” ou “SC”.

Versão: A versão do padrão. Novamente, isso deve corresponder à versão suportada pelo ASR e à versão nos dados de busca.

Controle: O ID de controle do controle a ser remediado. Isso deve corresponder aos dados de descoberta.

1. Crie um runbook na (s) conta (s) do membro.

2. Crie uma função do IAM na (s) conta (s) do membro.

3. (Opcional) Crie uma regra de remediação automática na conta do administrador.

Etapa 1. Crie um runbook na (s) conta (s) do membro

1. Faça login no console do AWS Systems Manager e obtenha um exemplo da descoberta de JSON.

2. Crie um runbook de automação que corrija a descoberta. Na guia Propriedade minha, use qualquer um dos ASR- documentos na guia Documentos como ponto de partida.

3. O AWS Step Functions na conta de administrador executará seu runbook. Seu runbook deve especificar a função de remediação para ser aprovado ao chamar o runbook.

Etapa 2. Crie uma função do IAM na (s) conta (s) do membro

1. Faça login no console do AWS Identity and Access Management.

2. Obtenha um exemplo das funções do IAM SO0111 e crie uma nova função. O nome da função deve começar com SO0111-remediate- - -. <standard> <version> <control> Por exemplo, se adicionar o controle 5.6 do CIS v1.2.0, a função deverá ser. SO0111-Remediate-CIS-1.2.0-5.6

3. Usando o exemplo, crie uma função com escopo adequado que permita que somente as chamadas de API necessárias realizem a correção.

Neste momento, sua remediação está ativa e disponível para remediação automatizada a partir da ASR Custom Action no AWS Security Hub.

Etapa 3: (opcional) criar uma regra de correção automática na conta do administrador

A remediação automática (não “automatizada”) é a execução imediata da remediação assim que a descoberta é recebida pelo AWS Security Hub. Considere cuidadosamente os riscos antes de usar essa opção.

1. Veja um exemplo de regra para o mesmo padrão de segurança em CloudWatch Eventos. O padrão de nomenclatura para regras éstandard_control_*AutoTrigger*.

2. Copie o padrão de evento do exemplo a ser usado.

3. Altere o GeneratorId valor para corresponder ao GeneratorId em seu Finding JSON.

4. Salve e ative a regra.

Visão geral do fluxo de trabalho do CDK

Em resumo, os seguintes arquivos no repositório ASR serão modificados ou adicionados. Neste exemplo, uma nova remediação para ElastiCache .2 foi adicionada aos manuais do SC e do AFSBP.

nota

Todas as novas remediações devem ser adicionadas ao manual do SC, pois ele consolida todas as remediações disponíveis no ASR. Se você pretende implantar somente um conjunto específico de manuais (por exemplo, AFSBP), você pode: (1) adicionar a correção somente aos manuais pretendidos ou (2) adicionar a correção a todos os manuais para os quais ela existe no Padrão do Security Hub correspondente, além do manual do SC. A segunda opção é recomendada para flexibilidade.

Neste exemplo, ElastiCache .2 está incluído nos seguintes padrões do Security Hub:

• AFSBP

• Nist.800-53.R5 SI-2

• NIST.800-53.R5 SI-2 (2)

• NIST.800-53.R5 SI-2 (4)

• NIST.800-53.R5 SI-2 (5)

• PCI DSS v4.0.1/6.3.3

Como, por padrão, o ASR implementa apenas manuais para AFSBP e NIST.800-53, adicionaremos essa nova correção a esses manuais, além do SC.

Modifique

• source/lib/remediation-runbook-stack.ts

• source/playbooks/AFSBP/lib/[nome padrão] _remediations.ts

• source/playbooks/NIST80053/lib/control_runbooks-construct.ts

• source/playbooks/NIST80053/lib/[nome padrão] _remediations.ts

• source/playbooks/SC/lib/control_runbooks-construct.ts

• source/playbooks/SC/lib/sc_remediações.ts

• source/test/regex_registry.ts

Adicionar

• source/playbooks/SC/ssmdocs/SC_ ElastiCache .2.ts

• source/playbooks/SC/ssmdocs/descriptions/ElastiCache2.md

• source/remediation_runbooks/EnableElastiCacheVersionUpgrades.yaml

nota

O nome escolhido para o runbook pode ser qualquer string, desde que seja consistente com o restante das alterações feitas.

• source/playbooks/NIST80053/ssmdocs/NIST80053_ 2.ts ElastiCache

• source/playbooks/AFSBP/ssmdocs/AFSBP_ ElastiCache .2.yaml

Etapas de desenvolvimento

1. Crie o Runbook de Remediação.

2. Crie os Control Runbooks.

3. Integre cada manual de controle com um manual.

4. Crie a função do IAM de remediação e integre o runbook de remediação

5. Atualizar testes unitários

Etapa 1: Criar o Runbook de Remediação

Este é o documento SSM usado para remediar recursos. Ele deve incluir o AutomationAssumeRole parâmetro, que é a função do IAM com permissões para executar a correção. Visualize o arquivo existente source/remediation_runbooks/EnableElastiCacheVersionUpgrades.yaml como referência ao criar novos runbooks de remediação.

Todos os novos runbooks devem ser adicionados ao source/remediation_runbooks/ diretório.

Etapa 2: Criar os Runbooks de Controle

Um runbook de controle é um runbook específico de um manual que analisa os dados de busca de um determinado padrão e executa o manual de execução de remediação apropriado. Como estamos adicionando a remediação ElastiCache .2 aos manuais SC, AFSBP e NIST8 0053, precisamos criar um novo manual de controle para cada um. Os seguintes arquivos são criados:

• source/playbooks/SC/ssmdocs/SC_ ElastiCache .2.ts

• source/playbooks/NIST80053/ssmdocs/NIST80053_ 2.ts ElastiCache

• source/playbooks/AFSBP/ssmdocs/AFSBP_ ElastiCache .2.yaml

<CONTROL.ID>A nomeação desses arquivos é importante e deve seguir o formato <PLAYBOOK_NAME>_ .ts/yaml

Alguns manuais no ASR oferecem suporte aos runbooks de controle do IaC TypeScript, enquanto outros devem ser escritos em YAML bruto. Consulte as remediações existentes no respectivo manual como exemplos. Neste exemplo, abordaremos o manual do SC, que usa IaC.

No manual do SC, seu novo runbook de controle deve exportar uma classe que se estenda ControlRunbookDocument e corresponda ao nome do seu runbook de remediação. Dê uma olhada no exemplo abaixo:

export class EnableElastiCacheVersionUpgrades extends ControlRunbookDocument {
  constructor(scope: Construct, id: string, props: ControlRunbookProps) {
    super(scope, id, {
      ...props,
      securityControlId: 'ElastiCache.2',
      remediationName: 'EnableElastiCacheVersionUpgrades',
      scope: RemediationScope.REGIONAL,
      resourceIdRegex: <Regex>,
      resourceIdName: 'ClusterId',
      updateDescription: new StringFormat('Automatic minor version upgrades enabled for cluster %s.', [
        StringVariable.of(`ParseInput.ClusterId`),
      ]),
    });
  }
}

• securityControlIdé o ID de controle da remediação que você está adicionando, conforme definido na exibição de controles consolidados no Security Hub.

• remediationNameé o nome que você escolheu para o seu runbook de remediação.

• scopeé o escopo do recurso que você está remediando, indicando se ele existe globalmente ou em uma região específica.

• resourceIdRegexé o regex usado para capturar o ID do recurso que você gostaria de passar para o runbook de remediação como parâmetro. Somente um grupo deve ser capturado, todos os outros grupos não devem ser capturadores. Se você quiser passar o ARN inteiro, omita esse campo.

• resourceIdNameé o nome que você gostaria de definir para o ID do recurso capturado usandoresourceIdRegex. Ele deve corresponder ao nome do parâmetro do ID do recurso em seu runbook de remediação.

• updateDescriptioné a string que você gostaria de atribuir à seção “notas” da descoberta no Security Hub quando a correção for bem-sucedida.

Você também deve exportar uma função chamada createControlRunbook que retorna uma nova instância da sua classe. Para ElastiCache 1.2, isso se parece com:

export function createControlRunbook(scope: Construct, id: string, props: PlaybookProps): ControlRunbookDocument {
  return new EnableElastiCacheVersionUpgrades(scope, id, { ...props, controlId: 'ElastiCache.2' });
}

onde controlId está o ID de controle, conforme definido no Padrão de Segurança associado ao manual sob o qual você está operando.

Se o controle do Security Hub tiver parâmetros que você gostaria de passar para o seu runbook de remediação, você poderá passá-los adicionando substituições aos seguintes métodos: -getExtraSteps: define valores padrão para cada parâmetro implementado para o controle no Security Hub

nota

Cada parâmetro do Security Hub deve receber um valor padrão

• getInputParamsStepOutput: define as saídas para a GetInputParams etapa do runbook de controle

• Cada saída tem um nameoutputType, selector e. selectorDeve ser o mesmo seletor usado na substituição do getExtraSteps método.

• getRemediationParams: define os parâmetros passados para o runbook de remediação, obtidos nas saídas da GetInputParams etapa.

Para ver um exemplo, navegue até o source/playbooks/SC/ssmdocs/SC_DynamoDB.1.ts arquivo.

Etapa 3: Integrar cada manual de controle com um manual

Para cada runbook de controle criado na etapa anterior, agora você deve integrá-lo às definições de infraestrutura no manual associado. Siga as etapas abaixo para cada runbook de controle.

Importante

Se você criou o runbook de controle usando YAML bruto em vez de IaC datilografado, vá para a próxima seção.

Em /<playbook_name>/control_runbooks-construct.ts Importar seu arquivo de runbook de controle recém-criado, como:

import * as elasticache_2 from '../ssmdocs/SC_ElastiCache.2';

Em seguida, vá para a matriz para

const controlRunbooksRecord: Record<string, any>

E adicione uma nova entrada mapeando o ID de controle (específico do manual) para o createControlRunbook método que você criou:

'ElastiCache.2': elasticache_2.createControlRunbook,

Adicione o ID de controle específico do manual à lista de remediações, conforme abaixo: <playbook_name>\_remediations.ts

{ control: 'ElastiCache.2', versionAdded: '2.3.0' },

O versionAdded campo deve ser a versão mais recente da solução. Se a adição da remediação violar o limite de tamanho do modelo, aumente o. versionAdded Você pode ajustar o número de remediações incluídas na pilha de cada membro do manual. solution_env.sh

Etapa 4: criar a função do IAM de remediação e integrar o runbook de remediação

Cada remediação tem sua própria função do IAM com permissões personalizadas necessárias para executar o runbook de remediação. Além disso, o RunbookFactory.createRemediationRunbook método precisa ser invocado para adicionar o runbook de remediação que você criou na Etapa 1 aos modelos da solução. CloudFormation

Noremediation-runook-stack.ts, cada remediação tem seu próprio bloco de código na RemediationRunbookStack classe. O bloco de código a seguir mostra a criação de uma nova função do IAM e a integração do runbook de remediação para a remediação ElastiCache .2:

    //-----------------------
    // EnableElastiCacheVersionUpgrades
    //
    {
      const remediationName = 'EnableElastiCacheVersionUpgrades'; // should match the name of your remediation runbook
      const inlinePolicy = new Policy(props.roleStack, `ASR-Remediation-Policy-${remediationName}`);

      const remediationPolicy = new PolicyStatement();
      remediationPolicy.addActions('elasticache:ModifyCacheCluster');
      remediationPolicy.effect = Effect.ALLOW;
      remediationPolicy.addResources(`arn:${this.partition}:elasticache:*:${this.account}:cluster:*`);
      inlinePolicy.addStatements(remediationPolicy);

      new SsmRole(props.roleStack, 'RemediationRole ' + remediationName, { // creates the remediation IAM role
        solutionId: props.solutionId,
        ssmDocName: remediationName,
        remediationPolicy: inlinePolicy,
        remediationRoleName: `${remediationRoleNameBase}${remediationName}`,
      });

      RunbookFactory.createRemediationRunbook(this, 'ASR ' + remediationName, { // adds the remediation runbook to the solution's cloudformation templates
        ssmDocName: remediationName,
        ssmDocPath: ssmdocs,
        ssmDocFileName: `${remediationName}.yaml`,
        scriptPath: `${ssmdocs}/scripts`,
        solutionVersion: props.solutionVersion,
        solutionDistBucket: props.solutionDistBucket,
        solutionId: props.solutionId,
        namespace: namespace,
      });
    }

Etapa 5: atualizar os testes unitários

Recomendamos atualizar e executar os testes de unidade após adicionar uma nova correção.

Primeiro, você deve adicionar quaisquer novas expressões regulares (que ainda não tenham sido adicionadas) ao source/test/regex_registry.ts arquivo. Esse arquivo impõe testes para cada nova expressão regular incluída nos runbooks da solução. Veja a addElastiCacheClusterTestCases função como exemplo, usada para testar expressões regulares usadas em ElastiCache remediações.

Por fim, você precisará atualizar os instantâneos de cada pilha. Os instantâneos são definições de CloudFormation modelo com controle de versão que são usadas para rastrear as alterações feitas na infraestrutura do ASR. Você pode atualizar esses arquivos de instantâneo executando o seguinte comando no deployment diretório:

./run-unit-tests.sh update

Agora você está pronto para implantar sua nova remediação! Navegue até a seção Criar e implantar abaixo para obter instruções sobre como criar e implantar a solução com suas novas alterações.