Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Ajouter de nouvelles mesures correctives

Les corrections peuvent être ajoutées manuellement en mettant à jour les fichiers playbook appropriés, ou par programmation en étendant la solution via des constructions CDK, en fonction de votre flux de travail préféré.

Vue d'ensemble du flux de travail manuel

La réponse de sécurité automatisée sur les runbooks AWS doit suivre la dénomination standard suivante :

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

Standard : Abréviation de la norme de sécurité. Cela doit correspondre aux normes prises en charge par l'ASR. Il doit s'agir de l'une des catégories « CIS », « AFSBP », « PCI », « NIST » ou « SC ».

Version : version de la norme. Encore une fois, cela doit correspondre à la version prise en charge par ASR et à la version figurant dans les données de recherche.

Contrôle : ID du contrôle à corriger. Cela doit correspondre aux données de recherche.

Étape 1. Créez un runbook sur le (s) compte (s) membre (s)

Étape 2. Création d'un rôle IAM dans le ou les comptes membres

À ce stade, votre correction est active et disponible pour une correction automatique à partir de l'action personnalisée ASR dans AWS Security Hub.

Étape 3 : (Facultatif) Créez une règle de correction automatique dans le compte administrateur

La correction automatique (et non « automatisée ») est l'exécution immédiate de la correction dès que le résultat est reçu par AWS Security Hub. Réfléchissez bien aux risques avant d'utiliser cette option.

Présentation du flux de travail CDK

En résumé, les fichiers suivants du dépôt ASR seront modifiés ou ajoutés. Dans cet exemple, une nouvelle correction pour la version ElastiCache 2 a été ajoutée aux playbooks SC et AFSBP.

Dans cet exemple, la norme ElastiCache .2 est incluse dans les normes Security Hub suivantes :

Étant donné que, par défaut, ASR n'implémente que les playbooks pour AFSBP et NIST.800-53, nous ajouterons cette nouvelle correction à ces playbooks en plus du SC.

Modify

Addition

Étapes de développement

Étape 1 : Création du runbook de correction

Il s'agit du document SSM utilisé pour corriger les ressources. Il doit inclure le AutomationAssumeRole paramètre, qui est le rôle IAM autorisé à exécuter la correction. Affichez le fichier existant source/remediation_runbooks/EnableElastiCacheVersionUpgrades.yaml comme référence lors de la création de nouveaux runbooks de correction.

Tous les nouveaux runbooks doivent être ajoutés au source/remediation_runbooks/ répertoire.

Étape 2 : Création des Control Runbooks

Un runbook de contrôle est un runbook spécifique au playbook qui analyse les données de recherche issues de la norme donnée et exécute le runbook de correction approprié. Étant donné que nous ajoutons la correction ElastiCache .2 aux playbooks SC, AFSBP et NIST8 0053, nous devons créer un nouveau runbook de contrôle pour chacun d'eux. Les fichiers suivants sont créés :

Certains playbooks en ASR prennent en charge les runbooks de contrôle iAC TypeScript, tandis que d'autres doivent être écrits en YAML brut. Référez-vous aux correctifs existants dans le playbook correspondant à titre d'exemples. Dans cet exemple, nous aborderons le playbook SC, qui utilise IaC.

Dans le playbook SC, votre nouveau runbook de contrôle doit exporter une classe qui étend ControlRunbookDocument et correspond au nom de votre runbook de remédiation. Regardez l'exemple ci-dessous :

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

Vous devez également exporter une fonction appelée createControlRunbook qui renvoie une nouvelle instance de votre classe. Pour la ElastiCache version 2, cela ressemble à :

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

où controlId est l'ID de contrôle tel que défini dans la norme de sécurité associée au playbook sous lequel vous opérez.

Si le contrôle Security Hub contient des paramètres que vous souhaitez transmettre à votre runbook de correction, vous pouvez les transmettre en ajoutant des remplacements aux méthodes suivantes : - getExtraSteps : définit les valeurs par défaut pour chaque paramètre implémenté pour le contrôle dans Security Hub

Pour voir un exemple, accédez au source/playbooks/SC/ssmdocs/SC_DynamoDB.1.ts fichier.

Étape 3 : Intégrer chaque Control Runbook à un Playbook

Pour chaque runbook de contrôle créé à l'étape précédente, vous devez désormais l'intégrer aux définitions d'infrastructure du playbook associé. Suivez les étapes ci-dessous pour chaque runbook de contrôle.

Dans /<playbook_name>/control_runbooks-construct.ts Importer votre nouveau fichier runbook de contrôle, tel que :

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

Ensuite, accédez au tableau pour

const controlRunbooksRecord: Record<string, any>

Et ajoutez une nouvelle entrée mappant l'ID de contrôle (spécifique au playbook) à la createControlRunbook méthode que vous avez créée :

'ElastiCache.2': elasticache_2.createControlRunbook,

Ajoutez l'ID de contrôle spécifique au playbook à la liste des corrections comme ci-dessous : <playbook_name>\_remediations.ts

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

Le versionAdded champ doit être la dernière version de la solution. Si l'ajout de la correction dépasse la limite de taille du modèle, augmentez leversionAdded. Vous pouvez ajuster le nombre de corrections incluses dans la pile de chaque membre du playbook. solution_env.sh

Étape 4 : Création du rôle IAM de correction et intégration du runbook de correction

Chaque correction possède son propre rôle IAM avec des autorisations personnalisées requises pour exécuter le runbook de correction. En outre, la RunbookFactory.createRemediationRunbook méthode doit être invoquée pour ajouter le runbook de correction que vous avez créé à l'étape 1 aux modèles de CloudFormation la solution.

Dans leremediation-runook-stack.ts, chaque correction possède son propre bloc de code dans la RemediationRunbookStack classe. Le bloc de code suivant montre la création d'un nouveau rôle IAM et l'intégration du runbook de correction pour la ElastiCache correction .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,
      });
    }

Étape 5 : Mettre à jour les tests unitaires

Nous vous recommandons de mettre à jour et d'exécuter les tests unitaires après avoir ajouté une nouvelle correction.

Tout d'abord, vous devez ajouter de nouvelles expressions régulières (qui ne sont pas déjà ajoutées) dans le source/test/regex_registry.ts fichier. Ce fichier impose des tests pour chaque nouvelle expression régulière incluse dans les runbooks de la solution. Examinez l'exemple de la addElastiCacheClusterTestCases fonction, qui est utilisée pour tester les expressions régulières utilisées dans ElastiCache les corrections.

Enfin, vous devez mettre à jour les instantanés pour chaque pile. Les instantanés sont des définitions de CloudFormation modèles contrôlées par version qui sont utilisées pour suivre les modifications apportées à l'infrastructure d'ASR. Vous pouvez mettre à jour ces fichiers instantanés en exécutant la commande suivante depuis le deployment répertoire :

./run-unit-tests.sh update

Vous êtes maintenant prêt à déployer votre nouvelle solution ! Accédez à la section Création et déploiement ci-dessous pour obtenir des instructions sur la création et le déploiement de la solution avec vos nouvelles modifications.