Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Aggiungere nuove correzioni

Le riparazioni possono essere aggiunte manualmente aggiornando i file del playbook appropriati o a livello di codice estendendo la soluzione tramite costrutti CDK, a seconda del flusso di lavoro preferito.

Panoramica del flusso di lavoro manuale

I runbook Automated Security Response on AWS devono seguire la seguente denominazione standard:

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

Standard: l'abbreviazione dello standard di sicurezza. Questo deve corrispondere agli standard supportati da ASR. Deve essere uno tra «CIS», «AFSBP», «PCI», «NIST» o «SC».

Versione: la versione dello standard. Anche in questo caso, deve corrispondere alla versione supportata da ASR e alla versione contenuta nei dati di ricerca.

Controllo: l'ID del controllo da correggere. Deve corrispondere ai dati di ricerca.

Passaggio 1. Crea un runbook negli account dei membri

Passaggio 2. Crea un ruolo IAM negli account dei membri

A questo punto, la riparazione è attiva e disponibile per la riparazione automatica tramite ASR Custom Action in AWS Security Hub.

Fase 3: (Facoltativo) Crea una regola di riparazione automatica nell'account amministratore

La correzione automatica (non «automatizzata») è l'esecuzione immediata della riparazione non appena il risultato viene ricevuto da AWS Security Hub. Valuta attentamente i rischi prima di utilizzare questa opzione.

Panoramica del flusso di lavoro CDK

In sintesi, i seguenti file nel repository ASR verranno modificati o aggiunti. In questo esempio, è stata aggiunta una nuova correzione per ElastiCache .2 ai playbook SC e AFSBP.

In questo esempio, ElastiCache .2 è incluso nei seguenti standard Security Hub:

Poiché, per impostazione predefinita, ASR implementa solo i playbook per AFSBP e NIST.800-53, aggiungeremo questa nuova correzione a tali playbook oltre a SC.

Modifica

Add

Fasi di sviluppo

Fase 1: Creare il Remediation Runbook

Questo è il documento SSM utilizzato per correggere le risorse. Deve includere il AutomationAssumeRole parametro, che è il ruolo IAM con le autorizzazioni per eseguire la riparazione. Visualizza il file esistente source/remediation_runbooks/EnableElastiCacheVersionUpgrades.yaml come riferimento durante la creazione di nuovi runbook di correzione.

Tutti i nuovi runbook devono essere aggiunti alla directory. source/remediation_runbooks/

Fase 2: Creare i Control Runbook

Un control runbook è un runbook specifico per un playbook che analizza i dati di ricerca dello standard specificato ed esegue il Remediation Runbook appropriato. Poiché stiamo aggiungendo la correzione ElastiCache .2 ai playbook SC, AFSBP e NIST8 0053, dobbiamo creare un nuovo runbook di controllo per ciascuno di essi. Vengono creati i seguenti file:

Alcuni playbook in ASR supportano i runbook di controllo IaC, mentre altri devono essere scritti in TypeScript formato YAML non elaborato. Fai riferimento alle correzioni esistenti nel rispettivo playbook come esempi. In questo esempio, tratteremo il playbook SC, che utilizza IAc.

Nel playbook SC, il nuovo runbook di controllo dovrebbe esportare una classe che si estende ControlRunbookDocument e corrisponde al nome del runbook di correzione. Date un'occhiata all'esempio seguente:

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`),
      ]),
    });
  }
}

È inoltre necessario esportare una funzione chiamata createControlRunbook che restituisce una nuova istanza della classe. Per ElastiCache .2, questo assomiglia a:

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

dove controlId è l'ID di controllo definito nello standard di sicurezza associato al playbook in base al quale si opera.

Se il controllo Security Hub ha parametri che desideri passare al tuo runbook di correzione, puoi passarli aggiungendo sostituzioni ai seguenti metodi: -getExtraSteps: definisce i valori predefiniti per ogni parametro implementato per il controllo in Security Hub

Per visualizzare un esempio, accedi al file. source/playbooks/SC/ssmdocs/SC_DynamoDB.1.ts

Passaggio 3: integra ogni Control Runbook con un playbook

Per ogni runbook di controllo creato nel passaggio precedente, ora è necessario integrarlo con le definizioni dell'infrastruttura nel playbook associato. Segui i passaggi seguenti per ogni runbook di controllo.

In /<playbook_name>/control_runbooks-construct.ts Importa il tuo file di control runbook appena creato come:

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

Quindi, vai all'array per

const controlRunbooksRecord: Record<string, any>

E aggiungi una nuova voce che mappi l'ID di controllo (specifico del playbook) al createControlRunbook metodo che hai creato:

'ElastiCache.2': elasticache_2.createControlRunbook,

Aggiungi l'ID di controllo specifico del playbook all'elenco delle correzioni nel modo seguente: <playbook_name>\_remediations.ts

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

Il versionAdded campo deve essere la versione più recente della soluzione. Se l'aggiunta della riparazione viola il limite di dimensione del modello, aumenta il. versionAdded Puoi modificare il numero di riparazioni incluse in ogni stack membro del playbook in. solution_env.sh

Fase 4: Creare il Remediation IAM Role & Integrate Remediation Runbook

Ogni riparazione ha il proprio ruolo IAM con autorizzazioni personalizzate necessarie per eseguire il runbook di riparazione. Inoltre, è necessario richiamare il RunbookFactory.createRemediationRunbook metodo per aggiungere il runbook di riparazione creato nel passaggio 1 ai modelli della soluzione. CloudFormation

Inremediation-runook-stack.ts, ogni correzione ha il proprio blocco di codice nella classe. RemediationRunbookStack Il seguente blocco di codice mostra la creazione di un nuovo ruolo IAM e l'integrazione del runbook di riparazione per la ElastiCache correzione .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,
      });
    }

Fase 5: Aggiornamento dei test unitari

Consigliamo di aggiornare ed eseguire gli unit test dopo aver aggiunto una nuova correzione.

Innanzitutto, è necessario aggiungere tutte le nuove espressioni regolari (che non siano già state aggiunte) nel source/test/regex_registry.ts file. Questo file impone il test per ogni nuova espressione regolare inclusa nei runbook della soluzione. Dai un'occhiata alla addElastiCacheClusterTestCases funzione come esempio, che viene utilizzata per testare le espressioni regolari utilizzate nelle ElastiCache riparazioni.

Infine, dovrai aggiornare le istantanee per ogni stack. Le istantanee sono definizioni di CloudFormation modelli controllate dalla versione che vengono utilizzate per tenere traccia delle modifiche apportate all'infrastruttura di ASR. È possibile aggiornare questi file di istantanee eseguendo il seguente comando dalla directory: deployment

./run-unit-tests.sh update

Ora sei pronto per implementare la tua nuova soluzione correttiva! Vai alla sezione Compila e distribuisci di seguito per istruzioni su come creare e distribuire la soluzione con le nuove modifiche.