As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # 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- {{}} - - {{}} {{}} **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. 1. Crie uma função do IAM na (s) conta (s) do membro. 1. (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](https://console.aws.amazon.com/systems-manager/home) e obtenha um exemplo da descoberta de JSON. 1. 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. 1. 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](https://console.aws.amazon.com/iam/home). 1. 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- - -. {{}} {{}} {{}} 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` 1. 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) Crie uma regra de remediaçã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*`. 1. Copie o padrão de evento do exemplo a ser usado. 1. Altere o `GeneratorId` valor para corresponder ao `GeneratorId` em seu Finding JSON. 1. 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. 1. Crie os Control Runbooks. 1. Integre cada manual de controle com um manual. 1. Crie a função do IAM de remediação e integre o runbook de remediação 1. 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 **Example** A nomeação desses arquivos é importante e deve seguir o formato \_ .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. Veja o 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: , 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](https://docs.aws.amazon.com/securityhub/latest/userguide/asff-changes-consolidation.html#securityhub-findings-format-changes-ids-titles) 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 usando`resourceIdRegex`. 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 `name``outputType`, `selector` e. `selector`Deve 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 `//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 ``` 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: ` \_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 No`remediation-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, que é 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.