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. **Nota** Le istruzioni che seguono sfruttano le risorse installate dalla soluzione come punto di partenza. Per convenzione, la maggior parte dei nomi delle risorse delle soluzioni contiene **ASR and/or ** **SO0111** per facilitarne l'individuazione e l'identificazione. ## Panoramica del flusso di lavoro manuale I runbook Automated Security Response on AWS devono seguire la seguente denominazione standard: ASR- - - {{}} {{}} {{}} **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. 1. Crea un runbook negli account dei membri. 1. Crea un ruolo IAM negli account dei membri. 1. (Facoltativo) Crea una regola di correzione automatica nell'account amministratore. ### Passaggio 1. Crea un runbook negli account dei membri 1. Accedi alla [console AWS Systems Manager](https://console.aws.amazon.com/systems-manager/home) e ottieni un esempio di come trovare JSON. 1. Crea un runbook di automazione che corregga il risultato. Nella scheda **Owned by me**, usa uno qualsiasi dei `ASR-` documenti nella scheda **Documenti** come punto di partenza. 1. AWS Step Functions nell'account amministratore eseguirà il tuo runbook. Il runbook deve specificare il ruolo di riparazione per poter essere passato quando si chiama il runbook. ### Passaggio 2. Crea un ruolo IAM negli account dei membri 1. Accedi alla console [AWS Identity and Access Management](https://console.aws.amazon.com/iam/home). 1. Ottieni un esempio dai ruoli IAM **SO0111** e crea un nuovo ruolo. Il nome del ruolo deve iniziare con SO0111-Remediate- - -. {{}} {{}} {{}} Ad esempio, se si aggiunge il controllo CIS v1.2.0 5.6, il ruolo deve essere. `SO0111-Remediate-CIS-1.2.0-5.6` 1. Utilizzando l'esempio, create un ruolo con un ambito appropriato che consenta solo le chiamate API necessarie per eseguire la correzione. 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. 1. Visualizza una regola di esempio per lo stesso standard di sicurezza in CloudWatch Events. Lo standard di denominazione per le regole è`standard_control_*AutoTrigger*`. 1. Copia il modello di evento dall'esempio da utilizzare. 1. Modifica il `GeneratorId` valore in modo che corrisponda a quello `GeneratorId` nel tuo Finding JSON. 1. Salva e attiva la regola. ## 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. **Nota** Tutte le nuove correzioni devono essere aggiunte al playbook SC, poiché consolida tutte le riparazioni disponibili in ASR. Se intendi distribuire solo un set specifico di playbook (ad esempio AFSBP), puoi: (1) aggiungere la correzione **solo** ai playbook desiderati oppure (2) aggiungere la correzione a tutti i playbook per i quali esiste nel corrispondente Security Hub Standard, oltre al playbook SC. La seconda opzione è consigliata per motivi di flessibilità. In questo esempio, ElastiCache .2 è incluso nei seguenti standard Security Hub: + AFSBP + NIST.800-53.5r 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 versione 4.0.1/6.3.3 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** + source/lib/remediation-runbook-stack.ts + source/playbooks/AFSBP/lib/[nome standard] \_remediations.ts + source/playbooks/NIST80053/lib/control\_runbooks-construct.ts + source/playbooks/NIST80053/lib/[nome standard] \_remediations.ts + source/playbooks/SC/lib/control\_runbooks-construct.ts + source/playbooks/SC/lib/sc\_riparazioni.ts + source/test/regex\_registry.ts **Add** + source/playbooks/SC/ssmdocs/SC\_.2.ts ElastiCache + source/playbooks/SC/ssmdocs/descriptions/ElastiCache.2.md + source/remediation\_runbooks/EnableElastiCacheVersionUpgrades.yaml **Nota** Il nome scelto per il runbook può essere qualsiasi stringa, purché sia coerente con il resto delle modifiche apportate. + source/playbooks/NIST80053/ssmdocs/NIST80053\_ 2.ts ElastiCache + source/playbooks/AFSBP/ssmdocs/AFSBP\_ ElastiCache .2.yaml **Fasi di sviluppo** 1. Crea il Remediation Runbook. 1. Create i Control Runbook. 1. Integra ogni Control Runbook con un playbook. 1. Crea il ruolo IAM di Remediation e integra il Remediation Runbook 1. Aggiorna i test unitari ### 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: + 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** La denominazione di questi file è importante e deve seguire il formato \_ .ts/yaml 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: , resourceIdName: 'ClusterId', updateDescription: new StringFormat('Automatic minor version upgrades enabled for cluster %s.', [ StringVariable.of(`ParseInput.ClusterId`), ]), }); } } ``` + `securityControlId`è l'ID di controllo per la correzione che si sta aggiungendo, così come definito nella [vista dei controlli consolidati in Security](https://docs.aws.amazon.com/securityhub/latest/userguide/asff-changes-consolidation.html#securityhub-findings-format-changes-ids-titles) Hub. + `remediationName`è il nome che hai scelto per il tuo runbook di correzione. + `scope`è l'ambito della risorsa da correggere, che indica se esiste a livello globale o in una regione specifica. + `resourceIdRegex`è l'espressione regolare utilizzata per acquisire l'ID della risorsa che si desidera passare al runbook di correzione come parametro. È necessario acquisire solo un gruppo, tutti gli altri gruppi non devono essere acquisiti. Se desideri passare l'intero ARN, ometti questo campo. + `resourceIdName`è il nome da impostare per l'ID della risorsa acquisito utilizzando`resourceIdRegex`, deve corrispondere al nome del parametro Resource ID nel runbook di correzione. + `updateDescription`è la stringa che si desidera assegnare alla sezione «note» del risultato in Security Hub una volta completata la riparazione. È 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 **Nota** A ogni parametro di Security Hub deve essere assegnato un valore predefinito + `getInputParamsStepOutput`: definisce gli output per la GetInputParams fase del control runbook + Ogni uscita ha un `name``outputType`, e. `selector` `selector`Dovrebbe essere lo stesso selettore utilizzato nell'override del `getExtraSteps` metodo. + `getRemediationParams`: definisce i parametri passati al runbook di correzione, recuperati dagli output degli step. GetInputParams 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. **Importante** Se hai creato il runbook di controllo utilizzando YAML non elaborato anziché typescript IaC, passa alla sezione successiva. In `//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 ``` 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: ` \_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 In`remediation-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.