【Tips】Prowler でカスタムチェックを作成する方法

作成日: 2024/01/14, 更新日: 2024/05/12

Prowler は、AWS や Azure、GCP アカウントのセキュリティ設定をチェックするためのツールです。
標準で用意されているチェック以外にも、カスタムチェックを作成することができます。
カスタムチェックの作成方法が公式ドキュメントに詳しく記載されていなかったので、ソースコードを分析してカスタムチェックの作成方法を確認しました。
本記事では、Prowler でカスタムチェックを作成する方法を記載いたします。

Prowler とは？
カスタムチェックについて公式ドキュメントに記載されている内容は？
（先に結論）カスタムチェックのファイル構成と内容
1. Prowler標準のクライアントを利用
2. 独自クライアントを利用
カスタムチェック開発中のデバッグ方法
Prowler のソースコードを読んでみた（v1.12.1 時点）
まとめ

Prowler とは？

GitHub - prowler-cloud/prowler において、以下のように説明されています。

Prowler は、AWS、Azure、Google Cloud、Kubernetes のセキュリティのベストプラクティスの評価、監査、インシデント対応、継続的な監視、強化とフォレンジックの準備、さらに修復を実行するオープンソースのセキュリティツールです。 Prowler Open Source と呼ばれる Prowler CLI (コマンドラインインターフェイス) と、 Prowler SaaSと呼ばれるその上のサービスがあります。
和訳元：GitHub - prowler-cloud/prowler

Prowler では CIS、NIST、PCI-DSS などのセキュリティフレームワークに基づいたチェックを実行することができます。
- 【Tips】CIS AWS Foundations Benchmark v3.0.0 に対応しているセキュリティチェックツールを調査（Security Hub, CFn Guard, Prowler）の記事にまとめましたが、Security Hub と比較しても Prowler はセキュリティフレームワークのうちかなり広範囲のルールをチェックすることができます。

カスタムチェックについて公式ドキュメントに記載されている内容は？

公式ドキュメントの以下のページにカスタムチェックについて記載されています。
- Miscellaneous - Prowler Documentation

以下は和訳した内容ですが、公式ドキュメントにはカスタムチェックの作成方法について大した内容は書いていません。チェックの詳細な書き方が記載されているとされる Developer Guide には、Prowler 自体の開発の方法が記載されておりカスタムチェックについては記載されていませんでした。

カスタムチェックフォルダーには、チェックごとに 1 つのサブフォルダーが含まれている必要があり、各サブフォルダーにはチェックの名前が付けられ、次のものが含まれている必要があります。

空の__init__.py: を指定すると、Python はこのチェックフォルダーをパッケージとして扱います。 check_name.pyチェックのロジックを含む。 check_name.metadata.jsonチェックのメタデータを含む。チェック名はサービス名で始まり、その後にアンダースコアが続く必要があります (例: ec2_instance_public_ip)。

チェックの書き方の詳細については、「開発者ガイド」を参照してください。
和訳元：Miscellaneous - Prowler Documentation

（先に結論）カスタムチェックのファイル構成と内容

カスタムチェックを作成する際のファイル構成として、「Prowler標準のクライアントを利用」「独自クライアントを利用」の2パターンを解説します。

Prowler標準のクライアントを利用

Prowler 標準のクライアントを利用する場合、以下のファイル構成でカスタムチェックを作成することができます。


                    ${親フォルダ名}/
                    ∟ ${AWSサービス名}_${チェック名}
                    　 ∟ __init__.py
                    　 ∟ ${AWSサービス名}_${チェック名}.py
                    　 ∟ ${AWSサービス名}_${チェック名}.metadata.json

                    # ファイル構成例：アカウントの代替連絡先情報が登録されているか確認するチェック
                    custom-checks-folder/
                    ∟ account_alternative_contact_information_is_registered/
                    　 ∟ __init__.py
                    　 ∟ account_alternative_contact_information_is_registered.py
                    　 ∟ account_alternative_contact_information_is_registered.metadata.json

${親フォルダ名} は適当なフォルダの名前を指定します。親フォルダ直下に ${AWSサービス名}_${チェック名} のフォルダを作成します。
親フォルダを置くフォルダはどのような入れ子構成でも構いません。ただし、引数で指定するフォルダはチェックフォルダを含む親フォルダのパスを指定する必要があります。
${AWSサービス名}_${チェック名} のフォルダは複数作成可能です。

${AWSサービス名} は必ず以下のうちいずれかを指定する必要があります。詳しい理由は後述します。（v3.12.1 時点）

AWSサービス名一覧

accessanalyzer
account
acm
apigateway
apigatewayv2
appstream
athena
autoscaling
awslambda
backup
cloudformation
cloudfront
cloudtrail
cloudwatch
codeartifact
codebuild
cognito
config
directoryservice
dlm
documentdb
drs
dynamodb
ec2
ecr
ecs
efs
eks
elasticache
elb
elbv2
emr
fms
glacier
globalaccelerator
glue
guardduty
iam
inspector2
kms
macie
neptune
networkfirewall
opensearch
organizations
rds
redshift
resourceexplorer2
route53
s3
sagemaker
secretsmanager
securityhub
shield
sns
sqs
ssm
ssmincidents
trustedadvisor
vpc
waf
wafv2
wellarchitected
workspaces

${チェック名} はチェックの名前をローワースネークケースで指定します。

つづいて、ファイルの内容を説明します。
ファイルの内容は prowler/prowler/providers/aws/services at master · prowler-cloud/prowler を参考に作成します。

__init__.py は空ファイルです。何も処理を書く必要はありません。

${AWSサービス名}_${チェック名}.py はチェックのロジックを記載します。
例えば、アカウントの代替連絡先情報が登録されているか確認するチェックを作成する場合は、以下のように記載します。
- チェックレポートを生成する処理はいくつかパターンがあるのですが、以下の例ではチェックした結果を「FAIL」または「PASS」で返すパターンを解説しています。
- ハイライトしている処理は基本的に必要なコードです。 Check_Report_AWS を生成したのち、 region 、 resource_arn 、 resource_id 、 status 、 status_extended resource_tags の値を設定します。
  - 詳細は Checks - Prowler Documentation を参照してください。
- レポートを生成するために、Prowler 標準のクライアント account_client を使用します。 account_client は Prowler の GitHub レポジトリの prowler/providers/aws/services/${AWSサービス名}/{AWSサービス名}_client.py および prowler/providers/aws/services/{AWSサービス名}/{AWSサービス名}_service.py で定義されており、 {AWSサービス名}_service.py の AWSService や BaseModel を継承したクラスの内容を見ることで、 account_client で使用できる変数を確認することができます。
  - ここで定義されていない変数を利用したい場合、独自にクライアントを作成する必要があります。詳細な方法は後述します。


                    import json
                    from prowler.lib.logger import logger
                    from prowler.lib.check.models import Check, Check_Report_AWS
                    from prowler.providers.aws.services.account.account_client import account_client


                    class account_alternative_contact_information_is_registered(Check):
                        def execute(self):
                            desired_alternative_contact_count = account_client.audit_config.get("desired_alternative_contact_count", 1)
                            findings = []
                            report = Check_Report_AWS(self.metadata())

                            # For each Prowler check we MUST fill the following
                            # Check_Report_AWS fields:
                            # - region
                            # - resource_id
                            # - resource_arn
                            # - status
                            # - status_extended
                            # - resource_tags (optional)

                            logger.debug(f"account_client.contact_names: {account_client.contact_names}")
                            logger.debug(f"account_client.contact_phone_numbers: {account_client.contact_phone_numbers}")
                            logger.debug(f"account_client.contact_emails: {account_client.contact_emails}")

                            contact_emails = account_client.contact_emails
                            contact_emails.discard(None)

                            report = Check_Report_AWS(self.metadata())
                            report.region = account_client.region
                            report.resource_arn = account_client.audited_account_arn
                            report.resource_id = account_client.audited_account

                            if len(contact_emails) != desired_alternative_contact_count:
                                report.status = "FAIL"
                            else:
                                report.status = "PASS"

                            report.status_extended = json.dumps(
                                {
                                    "desired_alternative_contact_count": desired_alternative_contact_count,
                                    "contact_emails_count": len(contact_emails),
                                    "contact_emails": list(contact_emails),
                                },
                            )

                            findings.append(report)

                            return findings

${AWSサービス名}_${チェック名}.metadata.json はチェックのメタデータを記載します。
アカウントの代替連絡先情報が登録されているか確認するチェックの場合は、以下のように記載します。
- メタデータのキーは必ず JSON 内に含める必要がありますが、一部のキーの値は空でも構いません。以下では必須であろう項目のみ値を指定してます。
- 以下の値の形式は満たす必要があります。
  - Provider は aws
  - CheckID は ${AWSサービス名}_${チェック名} ※ローワースネークケース
  - ServiceName は ${AWSサービス名} ※前出した通り、Prowler で定義されている AWS サービス名
  - Severity は low 、 medium 、 high 、 critical のいずれか


                    {
                      "Provider": "aws",
                      "CheckID": "account_alternative_contact_information_is_registered",
                      "CheckTitle": "Account alternative contact information is registered",
                      "CheckType": [
                        "IAM"
                      ],
                      "ServiceName": "account",
                      "SubServiceName": "",
                      "ResourceIdTemplate": "arn:partition:access-recorder:region:account-id:recorder/resource-id",
                      "Severity": "medium",
                      "ResourceType": "Other",
                      "Description": "",
                      "Risk": "",
                      "RelatedUrl": "",
                      "Remediation": {
                        "Code": {
                          "CLI": "",
                          "NativeIaC": "",
                          "Other": "",
                          "Terraform": ""
                        },
                        "Recommendation": {
                          "Text": "",
                          "Url": ""
                        }
                      },
                      "Categories": [
                        "custom-checks"
                      ],
                      "DependsOn": [],
                      "RelatedTo": [],
                      "Notes": ""
                    }

独自クライアントを利用

独自クライアントを利用する場合、以下のファイル構成でカスタムチェックを作成することができます。ファイルの命名は「Prowler標準のクライアントを利用」の場合と同じです。
- ハイライトしている cst_*.py のファイル名は任意でかまいませんが、読み込む際にわかりやすい名前にすることをお勧めします。


                    ${親フォルダ名}/
                    ∟ ${AWSサービス名}_${チェック名}
                    　 ∟ __init__.py
                    　 ∟ ${AWSサービス名}_${チェック名}.py
                    　 ∟ ${AWSサービス名}_${チェック名}.metadata.json
                    　 ∟ cst_${AWSサービス名}_client.py
                    　 ∟ cst_${AWSサービス名}_service.py

                    # ファイル構成例：Configの配信チャネルが有効になっているか確認するチェック
                    custom-checks-folder/
                    ∟ config_delivery_channel_enabled/
                    　 ∟ __init__.py
                    　 ∟ config_delivery_channel_enabled.py
                    　 ∟ config_delivery_channel_enabled.metadata.json
                    　 ∟ cst_config_client.py
                    　 ∟ cst_config_service.py

つづいて、ファイルの内容を説明します。
__init__.py 、 ${AWSサービス名}_${チェック名}.metadata.json は「Prowler標準のクライアントを利用」の場合と同じです。
${AWSサービス名}_${チェック名}.py ではクライアントの読み込み方法を変更する必要があります。ここでは、Configの配信チャネルが有効になっているか確認するチェックを作成する場合を例に説明します。
- ポイントとなるのは、以下の3-7行目です。 ${AWSサービス名}_${チェック名}/ ディレクトリ配下に置いたファイルはそのままだと読み込みに失敗してしまうため、ファイルが存在するディレクトリを sys.path.append で追加しています。


                    from prowler.lib.logger import logger
                    from prowler.lib.check.models import Check, Check_Report_AWS
                    import os
                    import sys

                    sys.path.append(os.path.join(os.path.dirname(__file__)))
                    from cst_config_client import config_client  # noqa: E402


                    class config_delivery_channel_enabled(Check):
                        def execute(self):
                            findings = []
                            report = Check_Report_AWS(self.metadata())

                    // 省略

cst_config_client.py ファイルの内容は以下になります。Configのカスタムクライアントを定義する場合を例に説明します。
- 内容はシンプルで、 cst_config_service.py で定義したクライアントをインスタンス化しています。


                    from prowler.providers.aws.lib.audit_info.audit_info import current_audit_info
                    from cst_config_service import Config

                    config_client = Config(current_audit_info)

cst_config_service.py ファイルの内容は以下になります。Configの配信レコーダーを定義する場合を例に説明します。
- 処理内容はProwler標準のクライアントの内容を元に開発を進めていきます。
- Config(AWSService) クラスではクライアントが初期化された場合に実行する処理を定義します。
  - __describe_delivery_channels__ 関数では、 regional_client.describe_delivery_channels() を実行し、Configの配信チャネルを取得しています。
  - DeliveryChannel クラスのインスタンスを生成し、 self.delivery_channels リストに追加しています。
  - self.delivery_channels リストには、Configの配信チャネルの情報が格納されています。この情報を元にチェックの結果を生成しています。
  - セキュリティ系のリソースを確認するような処理の場合、AWSリソースが存在しない場合の処理も定義が必要です。逆に、EC2インスタンスやS3バケットのように複数のAWSリソースを確認する処理の場合、ListやDescribeのAPIを実行してすべてのリソースの情報を取得する必要があります。
- DeliveryChannel(BaseModel) クラスでは、CloudFormation や API のドキュメントをベースに DeliveryChannel の構造を定義します。情報として必須ではないパラメータは Optional を指定します。AWSリソースが存在しない場合も結果を出力する場合、name と region 以外は None を指定することがあるため、 Optional を指定しています。
  - AWS::Config::DeliveryChannel - AWS CloudFormation
  - DescribeDeliveryChannels - AWS Config


                    from typing import Optional

                    from pydantic import BaseModel

                    from prowler.lib.logger import logger
                    from prowler.lib.scan_filters.scan_filters import is_resource_filtered
                    from prowler.providers.aws.lib.service.service import AWSService


                    class Config(AWSService):
                        def __init__(self, audit_info):
                            super().__init__(__class__.__name__, audit_info)
                            self.delivery_channels = []
                            self.__threading_call__(self.__describe_delivery_channels__)

                        def __describe_delivery_channels__(self, regional_client):
                            logger.info("Config - Listing Delivery Channels...")
                            try:
                                delivery_channel_count = 0
                                delivery_channels = regional_client.describe_delivery_channels()[
                                    "DeliveryChannels"
                                ]
                                for delivery_channel in delivery_channels:
                                    if not self.audit_resources or (
                                        is_resource_filtered(delivery_channel["name"], self.audit_resources)
                                    ):
                                        self.delivery_channels.append(
                                            DeliveryChannel(
                                                name=delivery_channel["name"],
                                                s3_bucket_name=delivery_channel["s3BucketName"],
                                                s3_key_prefix=delivery_channel["s3KeyPrefix"],
                                                sns_topic_arn=delivery_channel["snsTopicARN"],
                                                region=regional_client.region,
                                            )
                                        )
                                        delivery_channel_count += 1

                                # No delivery channels in region
                                if delivery_channel_count == 0:
                                    self.delivery_channels.append(
                                        DeliveryChannel(
                                            name=self.audited_account,
                                            s3_bucket_name=None,
                                            s3_key_prefix=None,
                                            sns_topic_arn=None,
                                            region=regional_client.region,
                                        )
                                    )
                            except Exception as error:
                                logger.error(
                                    f"{regional_client.region} -- {error.__class__.__name__}[{error.__traceback__.tb_lineno}]: {error}"
                                )


                    class DeliveryChannel(BaseModel):
                        name: str
                        s3_bucket_name: Optional[str]
                        s3_key_prefix: Optional[str]
                        sns_topic_arn: Optional[str]
                        region: str

カスタムチェック開発中のデバッグ方法

カスタムチェックを開発中にデバッグする方法としては、Prowler から実行するのが一番手っ取り早いです。
以下のように --checks オプションで開発中のチェックのみを指定し実行することでデバッグにかかる時間を短縮できます。
--log-level を指定すれば、loggerで出力したログを確認することができます。


                    prowler aws \
                    --checks-folder ./custom-checks-folder/ \
                    --checks \
                    account_alternative_contact_information_is_registered \
                    --log-level ERROR \
                    -M csv \
                    --output-directory ./output

DEBUG レベルのログを出力する際はターミナルだと確認し辛いため、、ログをファイルに出力することをお勧めします。


                    prowler aws \
                    --checks-folder ./custom-checks-folder/ \
                    --checks \
                    account_alternative_contact_information_is_registered \
                    --log-level DEBUG \
                    -M csv \
                    --output-directory ./output > debug.log 2>&1

Prowler のソースコードを読んでみた（v1.12.1 時点）

エントリーポイント - prowler()

Prowler のエントリーポイントは prowler/__main__.py の prowler() です。
Prowler 実行時の引数は以下のコードで読み込まれます。カスタムチェック用のフォルダを -x もしくは --checks-folder で指定した場合、 checks_folder に値が設定されます。


                    def prowler():
                        # Parse Arguments
                        parser = ProwlerArgumentParser()
                        args = parser.parse()

                        # Save Arguments
                        provider = args.provider
                        checks = args.checks
                        excluded_checks = args.excluded_checks
                        excluded_services = args.excluded_services
                        services = args.services
                        categories = args.categories
                        checks_file = args.checks_file
                        checks_folder = args.checks_folder
                        severities = args.severity
                        compliance_framework = args.compliance
                        custom_checks_metadata_file = args.custom_checks_metadata_file

引数が指定されている場合、 parse_checks_from_folder(audit_info, checks_folder, provider) 関数が呼び出されます。この関数では、カスタムチェック用のフォルダを読み込み、読み込んだフォルダ内のチェックファイルを Prowler の特定のパスへコピーします。この関数の動きがカスタムチェックのファイル構成と内容を決める重要なポイントとなるため、後ほど詳しく解説します。


                        # Import custom checks from folder
                        if checks_folder:
                            parse_checks_from_folder(audit_info, checks_folder, provider)

ファイルがコピーされた後、実行時に指定された引数を元に checks_to_execute リストを生成し、実行するチェックを絞り込みます。


                        # Exclude checks if -e/--excluded-checks
                        if excluded_checks:
                            checks_to_execute = exclude_checks_to_run(checks_to_execute, excluded_checks)

                        # Exclude services if --excluded-services
                        if excluded_services:
                            checks_to_execute = exclude_services_to_run(
                                checks_to_execute, excluded_services, provider
                            )

                        # Once the audit_info is set and we have the eventual checks based on the resource identifier,
                        # it is time to check what Prowler's checks are going to be executed
                        if audit_info.audit_resources:
                            checks_from_resources = set_provider_execution_parameters(provider, audit_info)
                            checks_to_execute = checks_to_execute.intersection(checks_from_resources)

                        # Sort final check list
                        checks_to_execute = sorted(checks_to_execute)

生成された checks_to_execute リストを元に、 execute_checks(checks_to_execute,provider,audit_info,audit_output_options,custom_checks_metadata) 関数が呼び出されます。この関数では、 checks_to_execute リストに含まれるチェックを実行し、結果を findings リストに格納します。この関数も独自のクライアントを作成する場合に少しつまずいたポイントとなるため、後ほど解説します。
この後の処理では、 findings リストを元にチェック結果を出力していますが、詳しい説明は割愛します。


                        # Execute checks
                        findings = []
                        if len(checks_to_execute):
                            findings = execute_checks(
                                checks_to_execute,
                                provider,
                                audit_info,
                                audit_output_options,
                                custom_checks_metadata,
                            )
                        else:
                            logger.error(
                                "There are no checks to execute. Please, check your input arguments"
                            )

最後にカスタムチェック用のフォルダが指定されていた場合、 remove_custom_checks_module(checks_folder, provider) 関数が呼び出されます。この関数では、カスタムチェック用のフォルダを削除します。


                        # If custom checks were passed, remove the modules
                        if checks_folder:
                            remove_custom_checks_module(checks_folder, provider)

フォルダのチェックを解析 - parse_checks_from_folder(audit_info, checks_folder, provider)

parse_checks_from_folder(audit_info, checks_folder, provider) 関数は prowler/lib/check/check.py で定義されています。
131-133行目で、 checks_folder が S3 URI であるかどうかを判定しています。S3 URI である場合、指定した URI 配下のプレフィックスのオブジェクトを確認し、ダウンロードします。
146-151行目で、 checks_folder 配下のフォルダを走査し、チェックフォルダを特定します。チェックフォルダが特定された場合、 checks_folder 配下のチェックフォルダを Prowler のパス {prowler_dir[0]}/providers/{provider}/services/{check_service}/{check.name} へコピーします。例えば、 custom-checks-folder/ account_alternative_contact_information_is_registered/ という構成の場合、 custom-checks-folder/account_alternative_contact_information_is_registered/ を {prowler_dir[0]}/providers/aws/services/account/account_alternative_contact_information_is_registered/ へコピーします。
- check_service = check.name.split("_")[0] の処理の通り、スネークケースの命名のうち最初の単語が AWS サービス名となります。この仕様のため、前述した通り AWS サービス名は Prowler ですでに定義されているものを使用する必要があります。
- 各AWSサービスのクライアントは {prowler_dir[0]}/providers/{provider}/services/{check_service}/ 配下で定義されているのですが、チェックフォルダのみコピーするという動きのため親フォルダ配下にカスタムのクライアントを置いたとしてもファイルはコピーされません。
- カスタムのクライアントを作成する場合、チェックフォルダ配下に同梱して置く必要があります。


                    def parse_checks_from_folder(audit_info, input_folder: str, provider: str) -> int:
                        try:
                            imported_checks = 0
                            # Check if input folder is a S3 URI
                            if provider == "aws" and re.search(
                                "^s3://([^/]+)/(.*?([^/]+))/$", input_folder
                            ):
                                bucket = input_folder.split("/")[2]
                                key = ("/").join(input_folder.split("/")[3:])
                                s3_resource = audit_info.audit_session.resource("s3")
                                bucket = s3_resource.Bucket(bucket)
                                for obj in bucket.objects.filter(Prefix=key):
                                    if not os.path.exists(os.path.dirname(obj.key)):
                                        os.makedirs(os.path.dirname(obj.key))
                                    if obj.key[-1] == "/":
                                        continue
                                    bucket.download_file(obj.key, obj.key)
                                input_folder = key
                            # Import custom checks by moving the checks folders to the corresponding services
                            with os.scandir(input_folder) as checks:
                                for check in checks:
                                    if check.is_dir():
                                        check_module = input_folder + "/" + check.name
                                        # Copy checks to specific provider/service folder
                                        check_service = check.name.split("_")[0]
                                        prowler_dir = prowler.__path__
                                        prowler_module = f"{prowler_dir[0]}/providers/{provider}/services/{check_service}/{check.name}"
                                        if os.path.exists(prowler_module):
                                            shutil.rmtree(prowler_module)
                                        shutil.copytree(check_module, prowler_module)
                                        imported_checks += 1
                            return imported_checks
                        except Exception as error:
                            logger.critical(
                                f"{error.__class__.__name__}[{error.__traceback__.tb_lineno}] -- {error}"
                            )
                            sys.exit(1)

チェックを実行 - execute_checks(checks_to_execute,provider,audit_info,audit_output_options,custom_checks_metadata)

execute_checks(checks_to_execute,provider,audit_info,audit_output_options,custom_checks_metadata) 関数は prowler/lib/check/check.py で定義されています。
--only-logs オプションを指定した場合の処理もあるのですが、以下にはデフォルトで実行される処理を記載します。
- 510-519行目の処理で checks_to_execute リストに含まれるチェックを実行し、結果を all_findings リストに格納します。
- execute 関数の中で importlib.import_module を使用してチェックファイルを読み込んだ際、 ModuleNotFoundError が発生した場合は logger.error でエラーを出力します。この ModuleNotFoundError は --checks オプションで指定したチェック名が見つからない場合と、チェック処理の Python スクリプト内でモジュールがうまく読み込めなかった場合の両方で発生します。どちらが原因で発生しているのか確認するためには、独自に用意した Python スクリプト内でデバッグ用のログを出力するなどし切り分けが必要です。


                            # Default execution
                            checks_num = len(checks_to_execute)
                            plural_string = "checks"
                            singular_string = "check"

                            check_noun = plural_string if checks_num > 1 else singular_string
                            print(
                                f"{Style.BRIGHT}Executing {checks_num} {check_noun}, please wait...{Style.RESET_ALL}\n"
                            )
                            with alive_bar(
                                total=len(checks_to_execute),
                                ctrl_c=False,
                                bar="blocks",
                                spinner="classic",
                                stats=False,
                                enrich_print=False,
                            ) as bar:
                                for check_name in checks_to_execute:
                                    # Recover service from check name
                                    service = check_name.split("_")[0]
                                    bar.title = (
                                        f"-> Scanning {orange_color}{service}{Style.RESET_ALL} service"
                                    )
                                    try:
                                        check_findings = execute(
                                            service,
                                            check_name,
                                            provider,
                                            audit_output_options,
                                            audit_info,
                                            services_executed,
                                            checks_executed,
                                            custom_checks_metadata,
                                        )
                                        all_findings.extend(check_findings)

                                    # If check does not exists in the provider or is from another provider
                                    except ModuleNotFoundError:
                                        logger.error(
                                            f"Check '{check_name}' was not found for the {provider.upper()} provider"
                                        )
                                    except Exception as error:
                                        logger.error(
                                            f"{check_name} - {error.__class__.__name__}[{error.__traceback__.tb_lineno}]: {error}"
                                        )
                                    bar()
                                bar.title = f"-> {Fore.GREEN}Scan completed!{Style.RESET_ALL}"
                        return all_findings

まとめ

Prowler のカスタムチェックを作成する際に必要な情報をまとめました。
Prowler では標準で用意されているチェックも多いですが、カスタムチェックを作成することで、企業のセキュリティポリシーに合わせたチェックを実行することができます。
Config ルールのように定期的/継続的にチェックを実行する必要がない、もしくは Config ルールにかかるコストを削減したい場合は、Prowler を利用することでコストを抑えながらチェックを実行することができます。
この記事を読んで、Prowler のカスタムチェックを作成する際に少しでもお役に立てれば幸いです。