Merge pull request #156 from CriticalSolutionsNetwork/Bugfix--Fix-SPO-output-for-Get-SPOSite

fix: Fix SPO output for Get-SPOSite

.github/workflows/powershell.yml

@@ -0,0 +1,50 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+#
+# https://github.com/microsoft/action-psscriptanalyzer
+# For more information on PSScriptAnalyzer in general, see
+# https://github.com/PowerShell/PSScriptAnalyzer
+
+name: PSScriptAnalyzer
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    - cron: '33 20 * * 4'
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    permissions:
+      contents: read # for actions/checkout to fetch code
+      security-events: write # for github/codeql-action/upload-sarif to upload SARIF results
+      actions: read # only required for a private repository by github/codeql-action/upload-sarif to get the Action run status
+    name: PSScriptAnalyzer
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Run PSScriptAnalyzer
+        uses: microsoft/psscriptanalyzer-action@6b2948b1944407914a58661c49941824d149734f
+        with:
+          # Check https://github.com/microsoft/action-psscriptanalyzer for more info about the options.
+          # The below set up runs PSScriptAnalyzer to your entire repository and runs some basic security rules.
+          path: .\source
+          recurse: true
+          # Include your own basic security rules. Removing this option will run all the rules
+          includeRule: '"PSAvoidGlobalAliases", "PSAvoidUsingConvertToSecureStringWithPlainText", "PSAvoidUsingPlainTextForPassword", "PSAvoidUsingInvokeExpression", "PSUseApprovedVerbs", "PSAvoidUsingPositionalParameters", "PSAvoidUsingEmptyCatchBlock", "PSAvoidUsingDeprecatedManifestFields", "PSAvoidUsingUserNameAndPasswordParams", "PSAvoidUsingCmdletAliases"'
+
+          output: results.sarif
+
+      # Upload the SARIF file generated in the previous step
+      - name: Upload SARIF results file
+        uses: github/codeql-action/upload-sarif@v2
+        with:
+          sarif_file: results.sarif

.gitignore

@@ -15,3 +15,6 @@ output/
 markdownissues.txt
 node_modules
 package-lock.json
+Aligned.xlsx
+test-gh1.ps1
+ModdedModules/*

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "cSpell.words": [
+        "Msol"
+    ]
+}

CHANGELOG.md

@@ -6,6 +6,350 @@ The format is based on and uses the types of changes according to [Keep a Change
 
 ### Fixed
 
+- Get-SPOSite command to return all but voided output for no code runs (Ex: PowerAutomate)
+
+## [0.1.27] - 2025-01-13
+
+### Added
+
+- Added additional error handling to connect function to identify problematic steps when they occur.
+- Added new method of verifying spo tenant for Connect-SPOService branch of connect function.
+- Added method to avoid "assembly already loaded" error in PNP Powershell function on first run, subsequent runs in the same session will still throw the error.
+
+## [0.1.26] - 2024-08-04
+
+### Added
+
+- Added `New-M365SecurityAuditAuthObject` function to create a new authentication object for the security audit for app-based authentication.
+
+### Changed
+
+- Changed authentication options to include parameter for authenticating with a certificate.
+- Changed verbose output to ensure methods for suppressing all forms of output are available.
+
+## [0.1.25] - 2024-07-23
+
+### Fixed
+
+- Fixed test 1.3.1 as notification window for password expiration is no longer required.
+
+## [0.1.24] - 2024-07-07
+
+### Added
+
+- New private function `Get-AuditMailboxDetail` for 6.1.2 and 6.1.3 tests to get the action details for the test.
+
+### Changed
+
+- Changed `Get-Action` function to include both dictionaries.
+
+### Fixed
+
+- Fixed Test 1.3.3 to be the simpler version of the test while including output to check for current users sharing calendars.
+- Safe Attachments logic and added `$DomainName` as input to 2.1.4 to test main policy.
+
+### Docs
+
+- Updated `about_M365FoundationsCISReport` help file with new functions and changes.
+- Updated `Invoke-M365SecurityAudit` help file with examples.
+- Updated `Export-M365SecurityAudit` help file with examples.
+
+## [0.1.23] - 2024-07-02
+
+# Fixed
+
+- SPO tests formatting and output.
+
+## [0.1.22] - 2024-07-01
+
+### Added
+
+- Added hash and compress steps to `Export-M365SecurityAuditTable` function.
+
+## [0.1.21] - 2024-07-01
+
+### Fixed
+
+- SPO tests formatting and output.
+
+## [0.1.22] - 2024-07-01
+
+### Added
+
+- Added hash and compress steps to `Export-M365SecurityAuditTable` function.
+
+## [0.1.21] - 2024-07-01
+
+### Fixed
+
+- Formatting for MgGraph tests.
+
+## [0.1.20] - 2024-06-30
+
+### Fixed
+
+- Fixed parameter validation for new parameters in `Invoke-M365SecurityAudit` function
+
+## [0.1.19] - 2024-06-30
+
+### Added
+
+- Added `ApprovedCloudStorageProviders` parameter to `Invoke-M365SecurityAudit` to allow for testing of approved cloud storage providers for 8.1.1.
+- Added `ApprovedFederatedDomains` parameter to `Invoke-M365SecurityAudit` to allow for testing of approved federated domains for 8.5.1.
+
+### Fixed
+
+- Fixed various MSTeams tests to be more accurate and include more properties in the output.
+
+## [0.1.18] - 2024-06-29
+
+### Added
+
+- Added `Get-PhishPolicyDetail` and `Test-PhishPolicyCompliance` private functions to help test for phishing policy compliance.
+
+### Fixed
+
+- Fixed various EXO test to be more accurate and include more properties in the output.
+
+#### Changed
+
+- Changed main function parameter for Domain to `DomainName`.
+
+## [0.1.17] - 2024-06-28
+
+### Fixed
+
+- Fixed `Get-ExceededLengthResultDetail` function paramter validation for Exported Tests to allow for Null.
+
+## [0.1.16] - 2024-06-26
+
+### Added
+
+- Added `Grant-M365SecurityAuditConsent` function to consent to the Microsoft Graph Powershell API for a user.
+
+## [0.1.15] - 2024-06-26
+
+### Fixed
+
+- Fixed test 8.6.1 to include all of the following properties in it's checks and output: `ReportJunkToCustomizedAddress`, `ReportNotJunkToCustomizedAddress`, `ReportPhishToCustomizedAddress`,`ReportJunkAddresses`,`ReportNotJunkAddresses`,`ReportPhishAddresses`,`ReportChatMessageEnabled`,`ReportChatMessageToCustomizedAddressEnabled`
+- Fixed help `about_M365FoundationsCISReport` examples.
+- Fixed `Export-M365SecurityAuditTable` to properly export when nested table tests are not included.
+
+### Changed
+
+- Changed output of failure reason and details for 8.5.3 and 8.6.1 to be in line with other tests.
+
+## [0.1.14] - 2024-06-23
+
+### Fixed
+
+- Fixed test 1.3.1 to include notification window for password expiration.
+- Fixed 6.1.1 test definition to include the correct connection.
+- Removed banner and warning from EXO and AzureAD connection step.
+- Fixed missing CommentBlock for `Remove-RowsWithEmptyCSVStatus` function.
+- Fixed formatting and color for various Write-Host messages.
+
+### Added
+
+- Added export to excel to `Export-M365SecurityAuditTable` function.
+- `Get-AdminRoleUserLicense` function to get the license of a user with admin roles for 1.1.1.
+- Skip MSOL connection confirmation to `Get-MFAStatus` function.
+- Added `Get-CISMgOutput` function to get the output of the Microsoft Graph API per test.
+- Added `Get-CISExoOutput` function to get the output of the Exchange Online API per test.
+- Added `Get-CISMSTeamsOutput` function to get the output of the Microsoft Teams API per test.
+- Added `Get-CISSPOOutput` function to get the output of the SharePoint Online API per test.
+- Added `Get-TestError` function to get the error output of a test.
+- Updated Microsoft Graph tests to utilize the new output functions ('1.1.1', '1.1.3', '1.2.1', '1.3.1', '5.1.2.3', '5.1.8.1', '6.1.2', '6.1.3')
+- Updated EXO tests to utilize the new output functions ('1.2.2', '1.3.3', '1.3.6', '2.1.1', '2.1.2', '2.1.3', '2.1.4', '2.1.5', '2.1.6', '2.1.7', '2.1.9', '3.1.1', '6.1.1', '6.1.2', '6.1.3', '6.2.1', '6.2.2', '6.2.3', '6.3.1', '6.5.1', '6.5.2', '6.5.3', '8.6.1').
+- Updated MSTeams tests to utilize the new output functions ('8.1.1', '8.1.2', '8.2.1', '8.5.1', '8.5.2', '8.5.3', '8.5.4', '8.5.5', '8.5.6', '8.5.7', '8.6.1')
+- Updated SPO tests to utilize the new output functions ('7.2.1', '7.2.2', '7.2.3', '7.2.4', '7.2.5', '7.2.6', '7.2.7', '7.2.9', '7.2.10', '7.3.1', '7.3.2', '7.3.4')
+
+## [0.1.13] - 2024-06-18
+
+### Added
+
+- Added tenant output to connect function.
+- Added skip tenant connection confirmation to main function.
+
+### Fixed
+
+- Fixed comment examples for `Export-M365SecurityAuditTable`.
+
+### Changed
+
+- Updated `Sync-CISExcelAndCsvData` to be one function.
+
+## [0.1.12] - 2024-06-17
+
+### Added
+
+- Added `Export-M365SecurityAuditTable` public function to export applicable audit results to a table format.
+- Added paramter to `Export-M365SecurityAuditTable` to specify output of the original audit results.
+- Added `Remove-RowsWithEmptyCSVStatus` public function to remove rows with empty status from the CSV file.
+- Added `Get-Action` private function to retrieve the action for the test 6.1.2 and 6.1.3 tests.
+- Added output modifications to tests that produce tables to ensure they can be exported with the new `Export-M365SecurityAuditTable` function.
+
+## [0.1.11] - 2024-06-14
+
+### Added
+
+- Added Get-MFAStatus function to help with auditing mfa for conditional access controls.
+
+### Fixed
+
+- Fixed 6.1.2/6.1.3 tests to minimize calls to the Graph API.
+- Fixed 2.1.1,2.1.4,2.1.5 to suppress error messages and create a standard object when no e5"
+
+## [0.1.10] - 2024-06-12
+
+### Added
+
+- Added condition comments to each test.
+
+### Fixed
+
+- Fixed csv CIS controls that were not matched correctly.
+
+## [0.1.9] - 2024-06-10
+
+### Fixed
+
+- Fixed bug in 1.1.1 that caused the test to fail/pass incorrectly. Added verbose output.
+
+### Docs
+
+- Updated helper csv formatting for one cis control.
+
+
+## [0.1.8] - 2024-06-09
+
+### Added
+
+- Added output type to functions.
+
+### Fixed
+
+- Whatif support for `Invoke-M365SecurityAudit`.
+- Whatif module output and module install process.
+
+## [0.1.7] - 2024-06-08
+
+### Added
+
+- Added pipeline support to `Sync-CISExcelAndCsvData` function for `[CISAuditResult[]]` input.
+
+### Changed
+
+- Updated `Connect-M365Suite` to make `TenantAdminUrl` an optional parameter.
+- Updated `Invoke-M365SecurityAudit` to make `TenantAdminUrl` an optional parameter.
+- Improved connection handling and error messaging in `Connect-M365Suite`.
+- Enhanced `Invoke-M365SecurityAudit` to allow flexible inclusion and exclusion of specific recommendations, IG filters, and profile levels.
+- SupportsShoudProcess to also bypass connection checks in `Invoke-M365SecurityAudit` as well as Disconnect-M365Suite.
+
+## [0.1.6] - 2024-06-08
+
+### Added
+
+- Added pipeline support to `Sync-CISExcelAndCsvData` function for `[CISAuditResult[]]` input.
+
+## [0.1.5] - 2024-06-08
+
+### Added
+
+- Updated test definitions for CIS Microsoft 365 Foundations Benchmark for better error handling and object output when errors occur.
+- Added a parameter to the `Initialize-CISAuditResult` function to allow for a static failed object to be created when an error occurs.
+- Refactored `Invoke-M365SecurityAudit` to include a new private function `Invoke-TestFunction` for executing test functions and handling errors.
+- Added a new private function `Measure-AuditResult` to calculate and display audit results.
+- Enhanced error logging to capture failed test details and display them at the end of the audit.
+- Added a private function `Get-RequiredModule` to initialize the `$requiredModules` variable for better code organization in the main script.
+- Updated `Test-MailboxAuditingE3` and `Test-MailboxAuditingE5` functions to use `Format-MissingAction` for structuring missing actions into a pipe-separated table format.
+- Added more verbose logging to `Test-BlockMailForwarding` and improved error handling for better troubleshooting.
+- Improved `Test-RestrictCustomScripts` to handle long URL lengths better by extracting and replacing common hostnames, and provided detailed output.
+- Added sorting to output.
+- Created new functions for improved modularity.
+- Parameter validation for Excel and CSV path in sync function.
+- Added Output type to tests.
+- Added `M365DomainForPWPolicyTest` parameter to `Invoke-M365SecurityAudit` to specify testing only the default domain for password expiration policy when '1.3.1' is included in the tests.
+
+### Fixed
+
+- Ensured the `Invoke-TestFunction` returns a `CISAuditResult` object, which is then managed in the `Invoke-M365SecurityAudit` function.
+- Corrected the usage of the join operation within `$details` in `Test-BlockMailForwarding` to handle arrays properly.
+- Fixed the logic in `Test-RestrictCustomScripts` to accurately replace and manage URLs, ensuring compliance checks are correctly performed.
+- Updated the `Test-MailboxAuditingE3` and `Test-MailboxAuditingE5` functions to handle the `$allFailures` variable correctly, ensuring accurate pass/fail results.
+- Fixed the connections in helper CSV and connect function.
+- Removed verbose preference from `Test-RestrictCustomScripts`.
+- Ensured that the output in `Test-BlockMailForwarding` does not include extra spaces between table headers and data.
+- Fixed output in `Test-MailboxAuditingE3` and `Test-MailboxAuditingE5` to correctly align with the new table format.
+- Added step 1 and step 2 in `Test-BlockMailForwarding` details to ensure comprehensive compliance checks.
+- Fixed the issue with the output in `Test-RestrictCustomScripts` to ensure no extra spaces between table headers and data.
+
+## [0.1.4] - 2024-05-30
+
+### Added
+
+- Test definitions filter function.
+- Logging function for future use.
+- Test grade written to console.
+
+### Changed
+
+- Updated sync function to include connection info.
+- Refactored connect/disconnect functions to evaluate needed connections.
+
+## [0.1.3] - 2024-05-28
+
+### Added
+
+- Array list to store the results of the audit.
+- Arraylist tests and helper template.
+- New testing function.
+- Missing properties to CSV.
+
+### Changed
+
+- Refactored object initialization to source `RecDescription`, `CISControl`, and `CISDescription` properties from the CSV.
+- Added `Automated` and `Connection` properties to the output object.
+- All test functions aligned with the test-template.
+- Initialize-CISAuditResult refactored to use global test definitions.
+
+### Fixed
+
+- Corrected test-template.
+- Details added to pass.
+
+### Docs
+
+- Updated comments and documentation for new functions.
+
+## [0.1.2] - 2024-04-29
+
+### Added
+
+- Automated and organized CSV testing and added test 1.1.1.
+- Functions to merge tests into an Excel benchmark.
+- Public function for merging tests.
+- Testing for guest users under test 1.1.4.
+- Error handling for `Get-AdminRoleUserLicense`.
+- Project URI and icon added to manifest.
+
+### Fixed
+
+- Format for `TestDefinitions.csv`.
+- Filename for `Test-AdministrativeAccountCompliance`.
+- Error handling in test 1.1.1.
+- Properties for skipping and including tests.
+
+### Docs
+
+- Updated comments for new functions.
+- Updated help documentation.
+- Updated online link in public function.
+
+## [0.1.1] - 2024-04-02
+
+### Fixed
+
 - Fixed Test-ModernAuthExchangeOnline Profile Level in object.
 
 ### Added
@@ -25,4 +369,4 @@ The format is based on and uses the types of changes according to [Keep a Change
 - A dynamic test loading system based on CSV input for flexibility in defining audit tests.
 - Comprehensive verbose logging to detail the steps being performed during an audit.
 - Comment-help documentation for the `Invoke-M365SecurityAudit` function with examples and usage details.
-- Attribution to CIS and licensing information under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License in the README.
+- Attribution to CIS and licensing information under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License in the README.

README copy.md

@@ -1,5 +1,6 @@
 # M365FoundationsCISReport Module
-
+[![PSScriptAnalyzer](https://github.com/CriticalSolutionsNetwork/M365FoundationsCISReport/actions/workflows/powershell.yml/badge.svg)](https://github.com/CriticalSolutionsNetwork/M365FoundationsCISReport/actions/workflows/powershell.yml)
+[![pages-build-deployment](https://github.com/CriticalSolutionsNetwork/M365FoundationsCISReport/actions/workflows/pages/pages-build-deployment/badge.svg)](https://github.com/CriticalSolutionsNetwork/M365FoundationsCISReport/actions/workflows/pages/pages-build-deployment)
 ## License
 
 This PowerShell module is based on CIS benchmarks and is distributed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. This means:
@@ -11,83 +12,87 @@ This PowerShell module is based on CIS benchmarks and is distributed under the C
 For full license details, please visit [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-nc-sa/4.0/deed.en).
 
 [Register for and download CIS Benchmarks](https://www.cisecurity.org/cis-benchmarks)
+# Table of Contents
+1. [Invoke-M365SecurityAudit](#Invoke-M365SecurityAudit)
+2. [Export-M365SecurityAuditTable](#Export-M365SecurityAuditTable)
+3. [Get-AdminRoleUserLicense](#Get-AdminRoleUserLicense)
+4. [Get-MFAStatus](#Get-MFAStatus)
+5. [Grant-M365SecurityAuditConsent](#Grant-M365SecurityAuditConsent)
+6. [New-M365SecurityAuditAuthObject](#New-M365SecurityAuditAuthObject)
+7. [Remove-RowsWithEmptyCSVStatus](#Remove-RowsWithEmptyCSVStatus)
+8. [Sync-CISExcelAndCsvData](#Sync-CISExcelAndCsvData)
+
+## Module Dependencies
+
+The `M365FoundationsCISReport` module relies on several other PowerShell modules to perform its operations. The default run ensures these modules are installed with the specified versions. Use -NoModuleCheck to skip this step if you have installed the required modules previously and would like to suppress any output for automated runs.
+
+### Required Modules for Audit Functions
+
+Default modules used for audit functions:
+
+- **ExchangeOnlineManagement**
+  - Required Version: `3.3.0`
+
+- **Microsoft.Graph**
+  - Required Version: `2.4.0`
+
+- **PnP.PowerShell** (Optional, if PnP App authentication is used for SharePoint Online)
+  - Required Version: `2.5.0`
+
+- **Microsoft.Online.SharePoint.PowerShell** (If PnP authentication is not used (Default) )
+  - Required Version: `16.0.24009.12000`
+
+- **MicrosoftTeams**
+  - Required Version: `5.5.0`
+
+- **ImportExcel** (If importing or exporting Excel files)
+  - Required Version: `7.8.9`
+
+# EXAMPLES
 
-## Invoke-M365SecurityAudit
-### Synopsis
-Invokes a security audit for Microsoft 365 environments.
-### Syntax
 ```powershell
+# Example 1: Performing a security audit based on CIS benchmarks
+$auditResults = Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com"
+$auditResults = Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -ApprovedCloudStorageProviders "DropBox" -ApprovedFederatedDomains "northwind.com"
+# Suppressed output for automated runs
+$auditResults = Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -NoModuleCheck -NoModuleCheck -DoNotConfirmConnections -Confirm:$false
 
-Invoke-M365SecurityAudit -TenantAdminUrl <String> -DomainName <String> [-DoNotConnect] [-DoNotDisconnect] [-NoModuleCheck] [-WhatIf] [-Confirm] [<CommonParameters>]
+# Example 2: Exporting a security audit and it's nested tables to zipped CSV files
+Export-M365SecurityAuditTable -AuditResults $auditResults -ExportPath "C:\temp" -ExportOriginalTests -ExportNestedTables
+    # Output Ex: 2024.07.07_14.55.55_M365FoundationsAudit_368B2E2F.zip
 
-Invoke-M365SecurityAudit -TenantAdminUrl <String> -DomainName <String> [-ELevel <String>] [-ProfileLevel <String>] [-DoNotConnect] [-DoNotDisconnect] [-NoModuleCheck] [-WhatIf] [-Confirm] [<CommonParameters>]
+# Example 3: Retrieving licenses for users in administrative roles
+Get-AdminRoleUserLicense
 
-Invoke-M365SecurityAudit -TenantAdminUrl <String> -DomainName <String> [-IncludeIG1] [-DoNotConnect] [-DoNotDisconnect] [-NoModuleCheck] [-WhatIf] [-Confirm] [<CommonParameters>]
-
-Invoke-M365SecurityAudit -TenantAdminUrl <String> -DomainName <String> [-IncludeIG2] [-DoNotConnect] [-DoNotDisconnect] [-NoModuleCheck] [-WhatIf] [-Confirm] [<CommonParameters>]
-
-Invoke-M365SecurityAudit -TenantAdminUrl <String> -DomainName <String> [-IncludeIG3] [-DoNotConnect] [-DoNotDisconnect] [-NoModuleCheck] [-WhatIf] [-Confirm] [<CommonParameters>]
-
-Invoke-M365SecurityAudit -TenantAdminUrl <String> -DomainName <String> [-IncludeRecommendation <String[]>] [-DoNotConnect] [-DoNotDisconnect] [-NoModuleCheck] [-WhatIf] [-Confirm] [<CommonParameters>]
-
-Invoke-M365SecurityAudit -TenantAdminUrl <String> -DomainName <String> [-SkipRecommendation <String[]>] [-DoNotConnect] [-DoNotDisconnect] [-NoModuleCheck] [-WhatIf] [-Confirm] [<CommonParameters>]
+# Example 4: Getting MFA status of users
+Get-MFAStatus -UserId "user@domain.com"
 
+# Example 5: Removing rows with empty status values from a CSV file
+Remove-RowsWithEmptyCSVStatus -FilePath "C:\Reports\Report.xlsx" -WorksheetName "Sheet1"
 
+# Example 6: Synchronizing CIS benchmark data with audit results
+Sync-CISExcelAndCsvData -ExcelPath "path\to\excel.xlsx" -CsvPath "path\to\data.csv" -SheetName "Combined Profiles"
 
+# Example 7: Granting Microsoft Graph permissions to the auditor
+Grant-M365SecurityAuditConsent -UserPrincipalNameForConsent 'user@example.com'
 
+# Example 8: (PowerShell 7.x Only) Creating a new authentication object for the security audit for app-based authentication.
+$authParams = New-M365SecurityAuditAuthObject `
+  -ClientCertThumbPrint "ABCDEF1234567890ABCDEF1234567890ABCDEF12" `
+  -ClientId "12345678-1234-1234-1234-123456789012" `
+  -TenantId "12345678-1234-1234-1234-123456789012" `
+  -OnMicrosoftUrl "yourcompany.onmicrosoft.com" `
+  -SpAdminUrl "https://yourcompany-admin.sharepoint.com"
+Invoke-M365SecurityAudit -AuthParams $authParams -TenantAdminUrl "https://yourcompany-admin.sharepoint.com"
 ```
-### Parameters
-| Name  | Alias  | Description | Required? | Pipeline Input | Default Value |
-| - | - | - | - | - | - |
-| <nobr>TenantAdminUrl</nobr> |  | The URL of the tenant admin. This parameter is mandatory. | true | false |  |
-| <nobr>DomainName</nobr> |  | The domain name of the Microsoft 365 environment. This parameter is mandatory. | true | false |  |
-| <nobr>ELevel</nobr> |  | Specifies the E-Level \(E3 or E5\) for the audit. This parameter is optional and can be combined with the ProfileLevel parameter. | false | false |  |
-| <nobr>ProfileLevel</nobr> |  | Specifies the profile level \(L1 or L2\) for the audit. This parameter is optional and can be combined with the ELevel parameter. | false | false |  |
-| <nobr>IncludeIG1</nobr> |  | If specified, includes tests where IG1 is true. | false | false | False |
-| <nobr>IncludeIG2</nobr> |  | If specified, includes tests where IG2 is true. | false | false | False |
-| <nobr>IncludeIG3</nobr> |  | If specified, includes tests where IG3 is true. | false | false | False |
-| <nobr>IncludeRecommendation</nobr> |  | Specifies specific recommendations to include in the audit. Accepts an array of recommendation numbers. | false | false |  |
-| <nobr>SkipRecommendation</nobr> |  | Specifies specific recommendations to exclude from the audit. Accepts an array of recommendation numbers. | false | false |  |
-| <nobr>DoNotConnect</nobr> |  | If specified, the cmdlet will not establish a connection to Microsoft 365 services. | false | false | False |
-| <nobr>DoNotDisconnect</nobr> |  | If specified, the cmdlet will not disconnect from Microsoft 365 services after execution. | false | false | False |
-| <nobr>NoModuleCheck</nobr> |  | If specified, the cmdlet will not check for the presence of required modules. | false | false | False |
-| <nobr>WhatIf</nobr> | wi |  | false | false |  |
-| <nobr>Confirm</nobr> | cf |  | false | false |  |
-### Inputs
- - None. You cannot pipe objects to Invoke-M365SecurityAudit.
 
-### Outputs
- - CISAuditResult\\[\] The cmdlet returns an array of CISAuditResult objects representing the results of the security audit.
+# NOTE
+Ensure that you have the necessary permissions and administrative roles in your Microsoft 365 environment to run these cmdlets. Proper configuration and setup are required for accurate audit results.
 
-### Note
-This module is based on CIS benchmarks and is governed by the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. For more details, visit: https://creativecommons.org/licenses/by-nc-sa/4.0/deed.en
+# TROUBLESHOOTING NOTE
+If you encounter any issues while using the cmdlets, ensure that your environment meets the module prerequisites. Check for any updates or patches that may address known bugs. For issues related to specific cmdlets, refer to the individual help files for troubleshooting tips.
 
-### Examples
-**EXAMPLE 1**
-```powershell
-Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -ELevel "E5" -ProfileLevel "L1"
-```
-Performs a security audit for the E5 level and L1 profile in the specified Microsoft 365 environment.
-
-**EXAMPLE 2**
-```powershell
-Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -IncludeIG1
-```
-Performs an audit including all tests where IG1 is true.
-
-**EXAMPLE 3**
-```powershell
-Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -SkipRecommendation '1.1.3', '2.1.1'
-```
-Performs an audit while excluding specific recommendations 1.1.3 and 2.1.1.
-
-**EXAMPLE 4**
-```powershell
-$auditResults = Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com"
-PS> $auditResults | Export-Csv -Path "auditResults.csv" -NoTypeInformation
-```
-Captures the audit results into a variable and exports them to a CSV file.
-
-### Links
-
- - [Online Version: [GitHub Repository URL]](#Online Version: [GitHub Repository URL])
+# SEE ALSO
+- [CIS Benchmarks](https://www.cisecurity.org/cis-benchmarks/)
+- [Microsoft 365 Security Documentation](https://docs.microsoft.com/en-us/microsoft-365/security/)
+- [PowerShell Documentation](https://docs.microsoft.com/en-us/powershell/)

SECURITY.md

@@ -0,0 +1,18 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 0.1.4   | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+Use this section to tell people how to report a vulnerability.
+
+Tell them where to go, how often they can expect to get an update on a
+reported vulnerability, what to expect if the vulnerability is accepted or
+declined, etc.

help/Export-M365SecurityAuditTable.md

@@ -0,0 +1,267 @@
+---
+external help file: M365FoundationsCISReport-help.xml
+Module Name: M365FoundationsCISReport
+online version: https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Export-M365SecurityAuditTable
+schema: 2.0.0
+---
+
+# Export-M365SecurityAuditTable
+
+## SYNOPSIS
+Exports M365 security audit results to a CSV file or outputs a specific test result as an object.
+
+## SYNTAX
+
+### OutputObjectFromAuditResultsSingle
+```
+Export-M365SecurityAuditTable [-AuditResults] <CISAuditResult[]> [-OutputTestNumber] <String>
+ [-ProgressAction <ActionPreference>] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+### ExportAllResultsFromAuditResults
+```
+Export-M365SecurityAuditTable [-AuditResults] <CISAuditResult[]> [-ExportNestedTables] -ExportPath <String>
+ [-ExportOriginalTests] [-ExportToExcel] [-Prefix <String>] [-ProgressAction <ActionPreference>] [-WhatIf]
+ [-Confirm] [<CommonParameters>]
+```
+
+### OutputObjectFromCsvSingle
+```
+Export-M365SecurityAuditTable [-CsvPath] <String> [-OutputTestNumber] <String>
+ [-ProgressAction <ActionPreference>] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+### ExportAllResultsFromCsv
+```
+Export-M365SecurityAuditTable [-CsvPath] <String> [-ExportNestedTables] -ExportPath <String>
+ [-ExportOriginalTests] [-ExportToExcel] [-Prefix <String>] [-ProgressAction <ActionPreference>] [-WhatIf]
+ [-Confirm] [<CommonParameters>]
+```
+
+## DESCRIPTION
+This function exports M365 security audit results from either an array of CISAuditResult objects or a CSV file.
+It can export all results to a specified path or output a specific test result as an object.
+
+## EXAMPLES
+
+### EXAMPLE 1
+```
+Export-M365SecurityAuditTable -AuditResults $object -OutputTestNumber 6.1.2
+# Output object for a single test number from audit results
+```
+
+### EXAMPLE 2
+```
+Export-M365SecurityAuditTable -ExportAllTests -AuditResults $object -ExportPath "C:\temp"
+# Export all results from audit results to the specified path
+```
+
+### EXAMPLE 3
+```
+Export-M365SecurityAuditTable -CsvPath "C:\temp\auditresultstoday1.csv" -OutputTestNumber 6.1.2
+# Output object for a single test number from CSV
+```
+
+### EXAMPLE 4
+```
+Export-M365SecurityAuditTable -ExportAllTests -CsvPath "C:\temp\auditresultstoday1.csv" -ExportPath "C:\temp"
+# Export all results from CSV to the specified path
+```
+
+### EXAMPLE 5
+```
+Export-M365SecurityAuditTable -ExportAllTests -AuditResults $object -ExportPath "C:\temp" -ExportOriginalTests
+# Export all results from audit results to the specified path along with the original tests
+```
+
+### EXAMPLE 6
+```
+Export-M365SecurityAuditTable -ExportAllTests -CsvPath "C:\temp\auditresultstoday1.csv" -ExportPath "C:\temp" -ExportOriginalTests
+# Export all results from CSV to the specified path along with the original tests
+```
+
+## PARAMETERS
+
+### -AuditResults
+An array of CISAuditResult objects containing the audit results.
+
+```yaml
+Type: CISAuditResult[]
+Parameter Sets: OutputObjectFromAuditResultsSingle, ExportAllResultsFromAuditResults
+Aliases:
+
+Required: True
+Position: 3
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -CsvPath
+The path to a CSV file containing the audit results.
+
+```yaml
+Type: String
+Parameter Sets: OutputObjectFromCsvSingle, ExportAllResultsFromCsv
+Aliases:
+
+Required: True
+Position: 3
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -OutputTestNumber
+The test number to output as an object.
+Valid values are "1.1.1", "1.3.1", "6.1.2", "6.1.3", "7.3.4".
+
+```yaml
+Type: String
+Parameter Sets: OutputObjectFromAuditResultsSingle, OutputObjectFromCsvSingle
+Aliases:
+
+Required: True
+Position: 2
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ExportNestedTables
+Switch to export all test results. When specified, all test results are exported to the specified path.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: ExportAllResultsFromAuditResults, ExportAllResultsFromCsv
+Aliases:
+
+Required: False
+Position: 1
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ExportPath
+The path where the CSV files will be exported.
+
+```yaml
+Type: String
+Parameter Sets: ExportAllResultsFromAuditResults, ExportAllResultsFromCsv
+Aliases:
+
+Required: True
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ExportOriginalTests
+Switch to export the original audit results to a CSV file.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: ExportAllResultsFromAuditResults, ExportAllResultsFromCsv
+Aliases:
+
+Required: False
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ExportToExcel
+Switch to export the results to an Excel file.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: ExportAllResultsFromAuditResults, ExportAllResultsFromCsv
+Aliases:
+
+Required: False
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -Prefix
+Add Prefix to filename after date when outputting to excel or csv.
+Validate that the count of letters in the prefix is less than 5.
+
+```yaml
+Type: String
+Parameter Sets: ExportAllResultsFromAuditResults, ExportAllResultsFromCsv
+Aliases:
+
+Required: False
+Position: Named
+Default value: Corp
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -WhatIf
+Shows what would happen if the cmdlet runs. The cmdlet is not run.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases: wi
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -Confirm
+Prompts you for confirmation before running the cmdlet.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases: cf
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ProgressAction
+{{ Fill ProgressAction Description }}
+
+```yaml
+Type: ActionPreference
+Parameter Sets: (All)
+Aliases: proga
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### CommonParameters
+This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see [about_CommonParameters](http://go.microsoft.com/fwlink/?LinkID=113216).
+
+## INPUTS
+
+### [CISAuditResult[]] - An array of CISAuditResult objects.
+### [string] - A path to a CSV file.
+## OUTPUTS
+
+### [PSCustomObject] - A custom object containing the path to the zip file and its hash.
+## NOTES
+
+## RELATED LINKS
+
+[https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Export-M365SecurityAuditTable](https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Export-M365SecurityAuditTable)
+

help/Get-AdminRoleUserLicense.md

@@ -0,0 +1,89 @@
+---
+external help file: M365FoundationsCISReport-help.xml
+Module Name: M365FoundationsCISReport
+online version: https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Get-AdminRoleUserLicense
+schema: 2.0.0
+---
+
+# Get-AdminRoleUserLicense
+
+## SYNOPSIS
+Retrieves user licenses and roles for administrative accounts from Microsoft 365 via the Graph API.
+
+## SYNTAX
+
+```
+Get-AdminRoleUserLicense [-SkipGraphConnection] [-ProgressAction <ActionPreference>] [<CommonParameters>]
+```
+
+## DESCRIPTION
+The Get-AdminRoleUserLicense function connects to Microsoft Graph and retrieves all users who are assigned administrative roles along with their user details and licenses.
+This function is useful for auditing and compliance checks to ensure that administrators have appropriate licenses and role assignments.
+
+## EXAMPLES
+
+### EXAMPLE 1
+```
+Get-AdminRoleUserLicense
+```
+
+This example retrieves all administrative role users along with their licenses by connecting to Microsoft Graph using the default scopes.
+
+### EXAMPLE 2
+```
+Get-AdminRoleUserLicense -SkipGraphConnection
+```
+
+This example retrieves all administrative role users along with their licenses without attempting to connect to Microsoft Graph, assuming that the connection is already established.
+
+## PARAMETERS
+
+### -SkipGraphConnection
+A switch parameter that, when set, skips the connection to Microsoft Graph if already established.
+This is useful for batch processing or when used within scripts where multiple calls are made and the connection is managed externally.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ProgressAction
+{{ Fill ProgressAction Description }}
+
+```yaml
+Type: ActionPreference
+Parameter Sets: (All)
+Aliases: proga
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### CommonParameters
+This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see [about_CommonParameters](http://go.microsoft.com/fwlink/?LinkID=113216).
+
+## INPUTS
+
+### None. You cannot pipe objects to Get-AdminRoleUserLicense.
+## OUTPUTS
+
+### PSCustomObject
+### Returns a custom object for each user with administrative roles that includes the following properties: RoleName, UserName, UserPrincipalName, UserId, HybridUser, and Licenses.
+## NOTES
+Creation Date:  2024-04-15
+Purpose/Change: Initial function development to support Microsoft 365 administrative role auditing.
+
+## RELATED LINKS
+
+[https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Get-AdminRoleUserLicense](https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Get-AdminRoleUserLicense)
+

help/Get-MFAStatus.md

@@ -0,0 +1,109 @@
+---
+external help file: M365FoundationsCISReport-help.xml
+Module Name: M365FoundationsCISReport
+online version: https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Get-MFAStatus
+schema: 2.0.0
+---
+
+# Get-MFAStatus
+
+## SYNOPSIS
+Retrieves the MFA (Multi-Factor Authentication) status for Azure Active Directory users.
+
+## SYNTAX
+
+```
+Get-MFAStatus [[-UserId] <String>] [-SkipMSOLConnectionChecks] [-ProgressAction <ActionPreference>]
+ [<CommonParameters>]
+```
+
+## DESCRIPTION
+The Get-MFAStatus function connects to Microsoft Online Service and retrieves the MFA status for all Azure Active Directory users, excluding guest accounts.
+Optionally, you can specify a single user by their User Principal Name (UPN) to get their MFA status.
+
+## EXAMPLES
+
+### EXAMPLE 1
+```
+Get-MFAStatus
+Retrieves the MFA status for all Azure Active Directory users.
+```
+
+### EXAMPLE 2
+```
+Get-MFAStatus -UserId "example@domain.com"
+Retrieves the MFA status for the specified user with the UPN "example@domain.com".
+```
+
+## PARAMETERS
+
+### -UserId
+The User Principal Name (UPN) of a specific user to retrieve MFA status for.
+If not provided, the function retrieves MFA status for all users.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: 1
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -SkipMSOLConnectionChecks
+{{ Fill SkipMSOLConnectionChecks Description }}
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ProgressAction
+{{ Fill ProgressAction Description }}
+
+```yaml
+Type: ActionPreference
+Parameter Sets: (All)
+Aliases: proga
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### CommonParameters
+This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see [about_CommonParameters](http://go.microsoft.com/fwlink/?LinkID=113216).
+
+## INPUTS
+
+## OUTPUTS
+
+### System.Object
+### Returns a sorted list of custom objects containing the following properties:
+### - UserPrincipalName
+### - DisplayName
+### - MFAState
+### - MFADefaultMethod
+### - MFAPhoneNumber
+### - PrimarySMTP
+### - Aliases
+## NOTES
+The function requires the MSOL module to be installed and connected to your tenant.
+Ensure that you have the necessary permissions to read user and MFA status information.
+
+## RELATED LINKS
+
+[https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Get-MFAStatus](https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Get-MFAStatus)
+

help/Grant-M365SecurityAuditConsent.md

@@ -0,0 +1,179 @@
+---
+external help file: M365FoundationsCISReport-help.xml
+Module Name: M365FoundationsCISReport
+online version: https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Grant-M365SecurityAuditConsent
+schema: 2.0.0
+---
+
+# Grant-M365SecurityAuditConsent
+
+## SYNOPSIS
+Grants Microsoft Graph permissions for an auditor.
+
+## SYNTAX
+
+```
+Grant-M365SecurityAuditConsent [-UserPrincipalNameForConsent] <String> [-SkipGraphConnection]
+ [-SkipModuleCheck] [-SuppressRevertOutput] [-DoNotDisconnect] [-ProgressAction <ActionPreference>] [-WhatIf]
+ [-Confirm] [<CommonParameters>]
+```
+
+## DESCRIPTION
+This function grants the specified Microsoft Graph permissions to a user, allowing the user to perform audits.
+It connects to Microsoft Graph, checks if a service principal exists for the client application, creates it if it does not exist, and then grants the specified permissions.
+Finally, it assigns the app to the user.
+
+## EXAMPLES
+
+### EXAMPLE 1
+```
+Grant-M365SecurityAuditConsent -UserPrincipalNameForConsent user@example.com
+```
+
+Grants Microsoft Graph permissions to user@example.com for the client application with the specified Application ID.
+
+### EXAMPLE 2
+```
+Grant-M365SecurityAuditConsent -UserPrincipalNameForConsent user@example.com -SkipGraphConnection
+```
+
+Grants Microsoft Graph permissions to user@example.com, skipping the connection to Microsoft Graph.
+
+## PARAMETERS
+
+### -UserPrincipalNameForConsent
+Specify the UPN of the user to grant consent for.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: True
+Position: 1
+Default value: None
+Accept pipeline input: True (ByPropertyName, ByValue)
+Accept wildcard characters: False
+```
+
+### -SkipGraphConnection
+If specified, skips connecting to Microsoft Graph.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -SkipModuleCheck
+If specified, skips the check for the Microsoft.Graph module.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -SuppressRevertOutput
+If specified, suppresses the output of the revert commands.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -DoNotDisconnect
+If specified, does not disconnect from Microsoft Graph after granting consent.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -WhatIf
+Shows what would happen if the cmdlet runs.
+The cmdlet is not run.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases: wi
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -Confirm
+Prompts you for confirmation before running the cmdlet.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases: cf
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ProgressAction
+{{ Fill ProgressAction Description }}
+
+```yaml
+Type: ActionPreference
+Parameter Sets: (All)
+Aliases: proga
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### CommonParameters
+This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see [about_CommonParameters](http://go.microsoft.com/fwlink/?LinkID=113216).
+
+## INPUTS
+
+## OUTPUTS
+
+### System.Void
+## NOTES
+This function requires the Microsoft.Graph module version 2.4.0 or higher.
+
+## RELATED LINKS
+
+[https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Grant-M365SecurityAuditConsent](https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Grant-M365SecurityAuditConsent)
+

help/Invoke-M365SecurityAudit.md

@@ -0,0 +1,487 @@
+---
+external help file: M365FoundationsCISReport-help.xml
+Module Name: M365FoundationsCISReport
+online version: https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Invoke-M365SecurityAudit
+schema: 2.0.0
+---
+
+# Invoke-M365SecurityAudit
+
+## SYNOPSIS
+Invokes a security audit for Microsoft 365 environments.
+
+## SYNTAX
+
+### Default (Default)
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>]
+ [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>] [-DoNotConnect]
+ [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections] [-AuthParams <CISAuthenticationParameters>]
+ [-ProgressAction <ActionPreference>] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+### ELevelFilter
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>] -ELevel <String>
+ -ProfileLevel <String> [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>]
+ [-DoNotConnect] [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections]
+ [-AuthParams <CISAuthenticationParameters>] [-ProgressAction <ActionPreference>] [-WhatIf] [-Confirm]
+ [<CommonParameters>]
+```
+
+### IG1Filter
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>] [-IncludeIG1]
+ [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>] [-DoNotConnect]
+ [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections] [-AuthParams <CISAuthenticationParameters>]
+ [-ProgressAction <ActionPreference>] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+### IG2Filter
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>] [-IncludeIG2]
+ [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>] [-DoNotConnect]
+ [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections] [-AuthParams <CISAuthenticationParameters>]
+ [-ProgressAction <ActionPreference>] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+### IG3Filter
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>] [-IncludeIG3]
+ [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>] [-DoNotConnect]
+ [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections] [-AuthParams <CISAuthenticationParameters>]
+ [-ProgressAction <ActionPreference>] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+### RecFilter
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>] -IncludeRecommendation <String[]>
+ [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>] [-DoNotConnect]
+ [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections] [-AuthParams <CISAuthenticationParameters>]
+ [-ProgressAction <ActionPreference>] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+### SkipRecFilter
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>] -SkipRecommendation <String[]>
+ [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>] [-DoNotConnect]
+ [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections] [-AuthParams <CISAuthenticationParameters>]
+ [-ProgressAction <ActionPreference>] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+## DESCRIPTION
+The Invoke-M365SecurityAudit cmdlet performs a comprehensive security audit based on the specified parameters.
+It allows auditing of various configurations and settings within a Microsoft 365 environment, such as compliance with CIS benchmarks.
+
+## EXAMPLES
+
+### EXAMPLE 1
+```
+Invoke-M365SecurityAudit
+```
+
+Performs a security audit using default parameters.
+Output:
+Status      : Fail
+ELevel      : E3
+ProfileLevel: L1
+Connection  : Microsoft Graph
+Rec         : 1.1.1
+Result      : False
+Details     : Non-compliant accounts:
+                Username        | Roles                  | HybridStatus | Missing Licence
+                user1@domain.com| Global Administrator   | Cloud-Only   | AAD_PREMIUM
+                user2@domain.com| Global Administrator   | Hybrid       | AAD_PREMIUM, AAD_PREMIUM_P2
+FailureReason: Non-Compliant Accounts: 2
+
+### EXAMPLE 2
+```
+Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -M365DomainForPWPolicyTest "contoso.com" -ELevel "E5" -ProfileLevel "L1"
+```
+
+Performs a security audit for the E5 level and L1 profile in the specified Microsoft 365 environment.
+Output:
+Status      : Fail
+ELevel      : E5
+ProfileLevel: L1
+Connection  : Microsoft Graph
+Rec         : 1.1.1
+Result      : False
+Details     : Non-compliant accounts:
+                Username        | Roles                  | HybridStatus | Missing Licence
+                user1@domain.com| Global Administrator   | Cloud-Only   | AAD_PREMIUM
+                user2@domain.com| Global Administrator   | Hybrid       | AAD_PREMIUM, AAD_PREMIUM_P2
+FailureReason: Non-Compliant Accounts: 2
+
+### EXAMPLE 3
+```
+Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -M365DomainForPWPolicyTest "contoso.com" -IncludeIG1
+```
+
+Performs an audit including all tests where IG1 is true.
+Output:
+Status      : Fail
+ELevel      : E3
+ProfileLevel: L1
+Connection  : Microsoft Graph
+Rec         : 1.1.1
+Result      : False
+Details     : Non-compliant accounts:
+                Username        | Roles                  | HybridStatus | Missing Licence
+                user1@domain.com| Global Administrator   | Cloud-Only   | AAD_PREMIUM
+                user2@domain.com| Global Administrator   | Hybrid       | AAD_PREMIUM, AAD_PREMIUM_P2
+FailureReason: Non-Compliant Accounts: 2
+
+### EXAMPLE 4
+```
+Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -M365DomainForPWPolicyTest "contoso.com" -SkipRecommendation '1.1.3', '2.1.1'
+Performs an audit while excluding specific recommendations 1.1.3 and 2.1.1.
+Output:
+Status      : Fail
+ELevel      : E3
+ProfileLevel: L1
+Connection  : Microsoft Graph
+Rec         : 1.1.1
+Result      : False
+Details     : Non-compliant accounts:
+                Username        | Roles                  | HybridStatus | Missing Licence
+                user1@domain.com| Global Administrator   | Cloud-Only   | AAD_PREMIUM
+                user2@domain.com| Global Administrator   | Hybrid       | AAD_PREMIUM, AAD_PREMIUM_P2
+FailureReason: Non-Compliant Accounts: 2
+```
+
+### EXAMPLE 5
+```
+$auditResults = Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -M365DomainForPWPolicyTest "contoso.com"
+PS> $auditResults | Export-Csv -Path "auditResults.csv" -NoTypeInformation
+```
+
+Captures the audit results into a variable and exports them to a CSV file.
+Output:
+CISAuditResult\[\]
+auditResults.csv
+
+### EXAMPLE 6
+```
+Invoke-M365SecurityAudit -WhatIf
+```
+
+Displays what would happen if the cmdlet is run without actually performing the audit.
+Output:
+What if: Performing the operation "Invoke-M365SecurityAudit" on target "Microsoft 365 environment".
+
+## PARAMETERS
+
+### -TenantAdminUrl
+The URL of the tenant admin.
+If not specified, none of the SharePoint Online tests will run.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -DomainName
+The domain name of the Microsoft 365 environment to test. This parameter is not mandatory and by default it will pass/fail all found domains as a group if a specific domain is not specified.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ELevel
+Specifies the E-Level (E3 or E5) for the audit.
+This parameter is optional and can be combined with the ProfileLevel parameter.
+
+```yaml
+Type: String
+Parameter Sets: ELevelFilter
+Aliases:
+
+Required: True
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ProfileLevel
+Specifies the profile level (L1 or L2) for the audit.
+This parameter is optional and can be combined with the ELevel parameter.
+
+```yaml
+Type: String
+Parameter Sets: ELevelFilter
+Aliases:
+
+Required: True
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -IncludeIG1
+If specified, includes tests where IG1 is true.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: IG1Filter
+Aliases:
+
+Required: True
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -IncludeIG2
+If specified, includes tests where IG2 is true.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: IG2Filter
+Aliases:
+
+Required: True
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -IncludeIG3
+If specified, includes tests where IG3 is true.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: IG3Filter
+Aliases:
+
+Required: True
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -IncludeRecommendation
+Specifies specific recommendations to include in the audit.
+Accepts an array of recommendation numbers.
+
+```yaml
+Type: String[]
+Parameter Sets: RecFilter
+Aliases:
+
+Required: True
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -SkipRecommendation
+Specifies specific recommendations to exclude from the audit.
+Accepts an array of recommendation numbers.
+
+```yaml
+Type: String[]
+Parameter Sets: SkipRecFilter
+Aliases:
+
+Required: True
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ApprovedCloudStorageProviders
+Specifies the approved cloud storage providers for the audit. Accepts an array of cloud storage provider names.
+
+```yaml
+Type: String[]
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: @()
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ApprovedFederatedDomains
+Specifies the approved federated domains for the audit test 8.2.1. Accepts an array of allowed domain names.
+
+```yaml
+Type: String[]
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -DoNotConnect
+If specified, the cmdlet will not establish a connection to Microsoft 365 services.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -DoNotDisconnect
+If specified, the cmdlet will not disconnect from Microsoft 365 services after execution.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -NoModuleCheck
+If specified, the cmdlet will not check for the presence of required modules.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -DoNotConfirmConnections
+If specified, the cmdlet will not prompt for confirmation before proceeding with established connections and will disconnect from all of them.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: False
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -AuthParams
+Specifies an authentication object containing parameters for application-based authentication. If provided, this will be used for connecting to services.
+
+```yaml
+Type: CISAuthenticationParameters
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -WhatIf
+Shows what would happen if the cmdlet runs.
+The cmdlet is not run.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases: wi
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -Confirm
+Prompts you for confirmation before running the cmdlet.
+
+```yaml
+Type: SwitchParameter
+Parameter Sets: (All)
+Aliases: cf
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ProgressAction
+{{ Fill ProgressAction Description }}
+
+```yaml
+Type: ActionPreference
+Parameter Sets: (All)
+Aliases: proga
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### CommonParameters
+This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see [about_CommonParameters](http://go.microsoft.com/fwlink/?LinkID=113216).
+
+## INPUTS
+
+### None. You cannot pipe objects to Invoke-M365SecurityAudit.
+## OUTPUTS
+
+### CISAuditResult[]
+### The cmdlet returns an array of CISAuditResult objects representing the results of the security audit.
+## NOTES
+- This module is based on CIS benchmarks.
+- Governed by the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
+- Commercial use is not permitted. This module cannot be sold or used for commercial purposes.
+- Modifications and sharing are allowed under the same license.
+- For full license details, visit: https://creativecommons.org/licenses/by-nc-sa/4.0/deed.en
+- Register for CIS Benchmarks at: https://www.cisecurity.org/cis-benchmarks
+
+## RELATED LINKS
+
+[https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Invoke-M365SecurityAudit](https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Invoke-M365SecurityAudit)
+

help/M365FoundationsCISReport.md

@@ -0,0 +1,37 @@
+---
+Module Name: M365FoundationsCISReport
+Module Guid: 0d064bfb-d1ce-484b-a173-993b55984dc9
+Download Help Link: {{Please enter Link manually}}
+Help Version: 1.0.0.0
+Locale: en-US
+---
+
+# M365FoundationsCISReport Module
+## Description
+The `M365FoundationsCISReport` module provides a set of cmdlets to audit and report on the security compliance of Microsoft 365 environments based on CIS (Center for Internet Security) benchmarks. It enables administrators to generate detailed reports, sync data with CIS Excel sheets, and perform security audits to ensure compliance.
+
+## M365FoundationsCISReport Cmdlets
+### [Export-M365SecurityAuditTable](Export-M365SecurityAuditTable)
+Exports M365 security audit results to a CSV file or outputs a specific test result as an object.
+
+### [Get-AdminRoleUserLicense](Get-AdminRoleUserLicense)
+Retrieves user licenses and roles for administrative accounts from Microsoft 365 via the Graph API.
+
+### [Get-MFAStatus](Get-MFAStatus)
+Retrieves the MFA (Multi-Factor Authentication) status for Azure Active Directory users.
+
+### [Grant-M365SecurityAuditConsent](Grant-M365SecurityAuditConsent)
+Grants Microsoft Graph permissions for an auditor.
+
+### [Invoke-M365SecurityAudit](Invoke-M365SecurityAudit)
+Invokes a security audit for Microsoft 365 environments.
+
+### [New-M365SecurityAuditAuthObject](New-M365SecurityAuditAuthObject)
+Creates a new CISAuthenticationParameters object for Microsoft 365 authentication.
+
+### [Remove-RowsWithEmptyCSVStatus](Remove-RowsWithEmptyCSVStatus)
+Removes rows from an Excel worksheet where the 'CSV_Status' column is empty and saves the result to a new file.
+
+### [Sync-CISExcelAndCsvData](Sync-CISExcelAndCsvData)
+Synchronizes and updates data in an Excel worksheet with new information from a CSV file, including audit dates.
+

help/New-M365SecurityAuditAuthObject.md

@@ -0,0 +1,149 @@
+---
+external help file: M365FoundationsCISReport-help.xml
+Module Name: M365FoundationsCISReport
+online version:
+schema: 2.0.0
+---
+
+# New-M365SecurityAuditAuthObject
+
+## SYNOPSIS
+Creates a new CISAuthenticationParameters object for Microsoft 365 authentication.
+
+## SYNTAX
+
+```
+New-M365SecurityAuditAuthObject [-ClientCertThumbPrint] <String> [-ClientId] <String> [-TenantId] <String>
+ [-OnMicrosoftUrl] <String> [-SpAdminUrl] <String> [-ProgressAction <ActionPreference>] [<CommonParameters>]
+```
+
+## DESCRIPTION
+The New-M365SecurityAuditAuthObject function constructs a new CISAuthenticationParameters object
+containing the necessary credentials and URLs for authenticating to various Microsoft 365 services.
+It validates input parameters to ensure they conform to expected formats and length requirements.
+An app registration in Azure AD with the required permissions to EXO, SPO, MSTeams and MgGraph is needed.
+
+## EXAMPLES
+
+### EXAMPLE 1
+```
+$authParams = New-M365SecurityAuditAuthObject -ClientCertThumbPrint "ABCDEF1234567890ABCDEF1234567890ABCDEF12" `
+                                                    -ClientId "12345678-1234-1234-1234-123456789012" `
+                                                    -TenantId "12345678-1234-1234-1234-123456789012" `
+                                                    -OnMicrosoftUrl "yourcompany.onmicrosoft.com" `
+                                                    -SpAdminUrl "https://yourcompany-admin.sharepoint.com"
+Creates a new CISAuthenticationParameters object with the specified credentials and URLs, validating each parameter's format and length.
+```
+
+## PARAMETERS
+
+### -ClientCertThumbPrint
+The thumbprint of the client certificate used for authentication.
+It must be a 40-character hexadecimal string.
+This certificate is used to authenticate the application in Azure AD.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: True
+Position: 1
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ClientId
+The Client ID (Application ID) of the Azure AD application.
+It must be a valid GUID format.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: True
+Position: 2
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -TenantId
+The Tenant ID of the Azure AD directory.
+It must be a valid GUID format representing your Microsoft 365 tenant.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: True
+Position: 3
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -OnMicrosoftUrl
+The URL of your onmicrosoft.com domain.
+It should be in the format 'example.onmicrosoft.com'.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: True
+Position: 4
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -SpAdminUrl
+The SharePoint admin URL, which should end with '-admin.sharepoint.com'.
+This URL is used for connecting to SharePoint Online.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: True
+Position: 5
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ProgressAction
+{{ Fill ProgressAction Description }}
+
+```yaml
+Type: ActionPreference
+Parameter Sets: (All)
+Aliases: proga
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### CommonParameters
+This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see [about_CommonParameters](http://go.microsoft.com/fwlink/?LinkID=113216).
+
+## INPUTS
+
+### None. You cannot pipe objects to this function.
+## OUTPUTS
+
+### CISAuthenticationParameters
+### The function returns an instance of the CISAuthenticationParameters class containing the authentication details.
+## NOTES
+Requires PowerShell 7.0 or later.
+
+## RELATED LINKS

help/Remove-RowsWithEmptyCSVStatus.md

@@ -0,0 +1,89 @@
+---
+external help file: M365FoundationsCISReport-help.xml
+Module Name: M365FoundationsCISReport
+online version:
+schema: 2.0.0
+---
+
+# Remove-RowsWithEmptyCSVStatus
+
+## SYNOPSIS
+Removes rows from an Excel worksheet where the 'CSV_Status' column is empty and saves the result to a new file.
+
+## SYNTAX
+
+```
+Remove-RowsWithEmptyCSVStatus [-FilePath] <String> [-WorksheetName] <String>
+ [-ProgressAction <ActionPreference>] [<CommonParameters>]
+```
+
+## DESCRIPTION
+The Remove-RowsWithEmptyCSVStatus function imports data from a specified worksheet in an Excel file, checks for the presence of the 'CSV_Status' column, and filters out rows where the 'CSV_Status' column is empty.
+The filtered data is then exported to a new Excel file with a '-Filtered' suffix added to the original file name.
+
+## EXAMPLES
+
+### EXAMPLE 1
+```
+Remove-RowsWithEmptyCSVStatus -FilePath "C:\Reports\Report.xlsx" -WorksheetName "Sheet1"
+This command imports data from the "Sheet1" worksheet in the "Report.xlsx" file, removes rows where the 'CSV_Status' column is empty, and saves the filtered data to a new file named "Report-Filtered.xlsx" in the same directory.
+```
+
+## PARAMETERS
+
+### -FilePath
+The path to the Excel file to be processed.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: True
+Position: 1
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -WorksheetName
+The name of the worksheet within the Excel file to be processed.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: True
+Position: 2
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ProgressAction
+{{ Fill ProgressAction Description }}
+
+```yaml
+Type: ActionPreference
+Parameter Sets: (All)
+Aliases: proga
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### CommonParameters
+This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see [about_CommonParameters](http://go.microsoft.com/fwlink/?LinkID=113216).
+
+## INPUTS
+
+## OUTPUTS
+
+## NOTES
+This function requires the ImportExcel module to be installed.
+
+## RELATED LINKS

help/Sync-CISExcelAndCsvData.md

@@ -0,0 +1,117 @@
+---
+external help file: M365FoundationsCISReport-help.xml
+Module Name: M365FoundationsCISReport
+online version: https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Sync-CISExcelAndCsvData
+schema: 2.0.0
+---
+
+# Sync-CISExcelAndCsvData
+
+## SYNOPSIS
+Synchronizes and updates data in an Excel worksheet with new information from a CSV file, including audit dates.
+
+## SYNTAX
+
+```
+Sync-CISExcelAndCsvData [[-ExcelPath] <String>] [[-CsvPath] <String>] [[-SheetName] <String>]
+ [-ProgressAction <ActionPreference>] [<CommonParameters>]
+```
+
+## DESCRIPTION
+The Sync-CISExcelAndCsvData function merges and updates data in a specified Excel worksheet from a CSV file.
+This includes adding or updating fields for connection status, details, failure reasons, and the date of the update.
+It's designed to ensure that the Excel document maintains a running log of changes over time, ideal for tracking remediation status and audit history.
+
+## EXAMPLES
+
+### EXAMPLE 1
+```
+Sync-CISExcelAndCsvData -ExcelPath "path\to\excel.xlsx" -CsvPath "path\to\data.csv" -SheetName "AuditData"
+Updates the 'AuditData' worksheet in 'excel.xlsx' with data from 'data.csv', adding new information and the date of the update.
+```
+
+## PARAMETERS
+
+### -ExcelPath
+Specifies the path to the Excel file to be updated.
+This parameter is mandatory.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: 1
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -CsvPath
+Specifies the path to the CSV file containing new data.
+This parameter is mandatory.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: 2
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -SheetName
+Specifies the name of the worksheet in the Excel file where data will be merged and updated.
+This parameter is mandatory.
+
+```yaml
+Type: String
+Parameter Sets: (All)
+Aliases:
+
+Required: False
+Position: 3
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### -ProgressAction
+{{ Fill ProgressAction Description }}
+
+```yaml
+Type: ActionPreference
+Parameter Sets: (All)
+Aliases: proga
+
+Required: False
+Position: Named
+Default value: None
+Accept pipeline input: False
+Accept wildcard characters: False
+```
+
+### CommonParameters
+This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see [about_CommonParameters](http://go.microsoft.com/fwlink/?LinkID=113216).
+
+## INPUTS
+
+### System.String
+### The function accepts strings for file paths and worksheet names.
+## OUTPUTS
+
+### None
+### The function directly updates the Excel file and does not output any objects.
+## NOTES
+- Ensure that the 'ImportExcel' module is installed and up to date to handle Excel file manipulations.
+- It is recommended to back up the Excel file before running this function to avoid accidental data loss.
+- The CSV file should have columns that match expected headers like 'Connection', 'Details', 'FailureReason', and 'Status' for correct data mapping.
+
+## RELATED LINKS
+
+[https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Sync-CISExcelAndCsvData](https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Sync-CISExcelAndCsvData)
+

help/about_M365FoundationsCISReport.md

@@ -0,0 +1,69 @@
+# M365FoundationsCISReport
+## about_M365FoundationsCISReport
+
+# SHORT DESCRIPTION
+The `M365FoundationsCISReport` module provides cmdlets for auditing and reporting on the security compliance of Microsoft 365 environments based on CIS benchmarks.
+
+# LONG DESCRIPTION
+The `M365FoundationsCISReport` module is designed to help administrators ensure that their Microsoft 365 environments adhere to the security best practices outlined by the Center for Internet Security (CIS). The module includes cmdlets for performing comprehensive security audits, generating detailed reports, and synchronizing audit results with CIS benchmark Excel sheets. It aims to streamline the process of maintaining security compliance and improving the overall security posture of Microsoft 365 environments.
+
+## Optional Subtopics
+### Auditing and Reporting
+The module provides cmdlets that allow for the auditing of various security aspects of Microsoft 365 environments, including user MFA status, administrative role licenses, and more. The results can be exported and analyzed to ensure compliance with CIS benchmarks.
+
+### Data Synchronization
+The module includes functionality to synchronize audit results with CIS benchmark data stored in Excel sheets. This ensures that the documentation is always up-to-date with the latest audit findings.
+
+# EXAMPLES
+```powershell
+# Example 1: Performing a security audit based on CIS benchmarks
+$auditResults = Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com"
+$auditResults = Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -ApprovedCloudStorageProviders "DropBox" -ApprovedFederatedDomains "northwind.com"
+
+# Example 2: Exporting a security audit and it's nested tables to zipped CSV files
+Export-M365SecurityAuditTable -AuditResults $auditResults -ExportPath "C:\temp" -ExportOriginalTests -ExportAllTests
+    # Output Ex: 2024.07.07_14.55.55_M365FoundationsAudit_368B2E2F.zip
+
+# Example 3: Retrieving licenses for users in administrative roles
+Get-AdminRoleUserLicense
+
+# Example 4: Getting MFA status of users
+Get-MFAStatus -UserId "user@domain.com"
+
+# Example 5: Removing rows with empty status values from a CSV file
+Remove-RowsWithEmptyCSVStatus -FilePath "C:\Reports\Report.xlsx" -WorksheetName "Sheet1"
+
+# Example 6: Synchronizing CIS benchmark data with audit results
+Sync-CISExcelAndCsvData -ExcelPath "path\to\excel.xlsx" -CsvPath "path\to\data.csv" -SheetName "Combined Profiles"
+
+# Example 7: Granting Microsoft Graph permissions to the auditor
+Grant-M365SecurityAuditConsent -UserPrincipalNameForConsent 'user@example.com'
+
+# Example 8: (PowerShell 7.x Only) Creating a new authentication object for the security audit for app-based authentication.
+$authParams = New-M365SecurityAuditAuthObject -ClientCertThumbPrint "ABCDEF1234567890ABCDEF1234567890ABCDEF12" `
+                                                            -ClientId "12345678-1234-1234-1234-123456789012" `
+                                                            -TenantId "12345678-1234-1234-1234-123456789012" `
+                                                            -OnMicrosoftUrl "yourcompany.onmicrosoft.com" `
+                                                            -SpAdminUrl "https://yourcompany-admin.sharepoint.com"
+Invoke-M365SecurityAudit -AuthParams $authParams -TenantAdminUrl "https://yourcompany-admin.sharepoint.com"
+```
+
+# NOTE
+Ensure that you have the necessary permissions and administrative roles in your Microsoft 365 environment to run these cmdlets. Proper configuration and setup are required for accurate audit results.
+
+# TROUBLESHOOTING NOTE
+If you encounter any issues while using the cmdlets, ensure that your environment meets the module prerequisites. Check for any updates or patches that may address known bugs. For issues related to specific cmdlets, refer to the individual help files for troubleshooting tips.
+
+# SEE ALSO
+- [CIS Benchmarks](https://www.cisecurity.org/cis-benchmarks/)
+- [Microsoft 365 Security Documentation](https://docs.microsoft.com/en-us/microsoft-365/security/)
+- [PowerShell Documentation](https://docs.microsoft.com/en-us/powershell/)
+
+# KEYWORDS
+- Microsoft 365
+- Security Audit
+- CIS Benchmarks
+- Compliance
+- MFA
+- User Licenses
+- Security Reporting

helpers/Automation Candidates.md

@@ -0,0 +1,52 @@
+# Automation Candidates
+
+## 5.1.1.1 (L1) Ensure Security Defaults is disabled on Azure Active Directory
+
+- `Connect-MgGraph -Scopes "Policy.Read.All"`
+- `Get-MgPolicyIdentitySecurityDefaultEnforcementPolicy | ft IsEnabled`
+
+## 5.1.2.1 (L1) Ensure 'Per-user MFA' is disabled
+
+- `Connect-MsolService`
+- Commands:
+
+```powershell
+$UserList = Get-MsolUser -All | Where-Object { $_.UserType -eq 'Member' }
+$Report = @()
+foreach ($user in $UserList) {
+    $PerUserMFAState = $null
+    if ($user.StrongAuthenticationRequirements) {
+        $PerUserMFAState = $user.StrongAuthenticationRequirements.State
+    }
+    else {
+        $PerUserMFAState = 'Disabled'
+    }
+    $obj = [pscustomobject][ordered]@{
+        UserPrincipalName = $User.UserPrincipalName
+        DisplayName       = $User.DisplayName
+        PerUserMFAState   = $PerUserMFAState
+    }
+    $Report += $obj
+}
+$Report
+```
+
+## 5.1.3.1 (L1) Ensure a dynamic group for guest users is created
+
+- `Connect-MgGraph -Scopes "Group.Read.All"`
+- Commands:
+
+```powershell
+$groups = Get-MgGroup | Where-Object { $_.GroupTypes -contains "DynamicMembership" }
+$groups | ft DisplayName,GroupTypes,MembershipRule
+```
+
+## 6.1.4 (L1) Ensure 'AuditBypassEnabled' is not enabled on mailboxes
+
+- `Connect-ExchangeOnline`
+- Commands:
+
+```powershell
+$MBX = Get-MailboxAuditBypassAssociation -ResultSize unlimited
+$MBX | where {$_.AuditBypassEnabled -eq $true} | Format-Table Name,AuditBypassEnabled
+```

helpers/Build-Help.ps1

@@ -1,15 +1,64 @@
 Import-Module .\output\module\M365FoundationsCISReport\*\*.psd1
+. .\source\Classes\CISAuditResult.ps1
 .\helpers\psDoc-master\src\psDoc.ps1 -moduleName M365FoundationsCISReport -outputDir docs -template ".\helpers\psDoc-master\src\out-html-template.ps1"
 .\helpers\psDoc-master\src\psDoc.ps1 -moduleName M365FoundationsCISReport -outputDir ".\" -template ".\helpers\psDoc-master\src\out-markdown-template.ps1" -fileName ".\README.md"
 
 
 <#
-    $ver = "v0.0.1"
+    $ver = "v0.1.28"
     git checkout main
     git pull origin main
-    git tag -a $ver -m "Release version $ver Minor Update"
+    git tag -a $ver -m "Release version $ver bugfix Update"
     git push origin $ver
     "Fix: PR #37"
     git push origin $ver
     # git tag -d $ver
-#>
+#>
+
+$OutputFolder = ".\help"
+$parameters = @{
+    Module = "M365FoundationsCISReport"
+    OutputFolder = $OutputFolder
+    AlphabeticParamsOrder = $true
+    WithModulePage = $true
+    ExcludeDontShow = $true
+    Encoding = [System.Text.Encoding]::UTF8
+}
+New-MarkdownHelp @parameters
+New-MarkdownAboutHelp -OutputFolder $OutputFolder -AboutName "M365FoundationsCISReport"
+
+
+####
+$parameters = @{
+    Path = ".\help"
+    RefreshModulePage = $true
+    AlphabeticParamsOrder = $true
+    UpdateInputOutput = $true
+    ExcludeDontShow = $true
+    LogPath = ".\log.txt"
+    Encoding = [System.Text.Encoding]::UTF8
+}
+Update-MarkdownHelpModule @parameters -Force
+Update-MarkdownHelpModule -Path ".\help" -RefreshModulePage -Force
+New-ExternalHelp -Path ".\help" -OutputPath ".\source\en-US" -force
+
+
+
+# Install Secret Management
+Install-Module -Name "Microsoft.PowerShell.SecretManagement", `
+"SecretManagement.JustinGrote.CredMan" -Scope CurrentUser
+
+# Register Vault
+Register-SecretVault -Name ModuleBuildCreds -ModuleName `
+"SecretManagement.JustinGrote.CredMan" -ErrorAction Stop
+
+
+#Set-Secret -Name "GalleryApiToken" -Vault ModuleBuildCreds
+#Set-Secret -Name "GitHubToken" -Vault ModuleBuildCreds
+
+
+$GalleryApiToken = Get-Secret -Name "GalleryApiToken" -Vault ModuleBuildCreds -AsPlainText
+$GitHubToken = Get-Secret -Name "GitHubToken" -Vault ModuleBuildCreds -AsPlainText
+
+$GalleryApiToken
+$GitHubToken

helpers/CIS 365 v3.0.0 Controls/Test-MailboxAuditingE3_6.1.2_E3L1_IG1_IG2_IG3.ps1

@@ -60,7 +60,7 @@ function Test-MailboxAuditingE3_6.1.2_E3L1_IG1_IG2_IG3 {
                     }
 
                     if ($missingActions) {
-                        $formattedActions = Format-MissingActions $missingActions
+                        $formattedActions = Format-MissingAction $missingActions
                         $allFailures += "$userUPN`: AuditEnabled - True; $formattedActions"
                     }
                     # Mark the user as processed
@@ -83,7 +83,7 @@ function Test-MailboxAuditingE3_6.1.2_E3L1_IG1_IG2_IG3 {
     }
 }
 
-function Format-MissingActions {
+function Format-MissingAction {
     param ([array]$missingActions)
 
     $actionGroups = @{

helpers/CIS 365 v3.0.0 Controls/Test-MailboxAuditingE5_6.1.3_E5L1_IG1_IG2_IG3.ps1

@@ -60,7 +60,7 @@ function Test-MailboxAuditingE5_6.1.3_E5L1_IG1_IG2_IG3 {
                     }
 
                     if ($missingActions) {
-                        $formattedActions = Format-MissingActions $missingActions
+                        $formattedActions = Format-MissingAction $missingActions
                         $allFailures += "$userUPN`: AuditEnabled - True; $formattedActions"
                     }
                     else {
@@ -92,7 +92,7 @@ function Test-MailboxAuditingE5_6.1.3_E5L1_IG1_IG2_IG3 {
     }
 }
 
-function Format-MissingActions {
+function Format-MissingAction {
     param ([array]$missingActions)
 
     $actionGroups = @{

helpers/CIS 365 v3.0.0 Controls/Test-Template.ps1

@@ -0,0 +1,97 @@
+function Test-Template {
+    [CmdletBinding()]
+    param (
+        # Parameters can be added if needed
+    )
+
+    begin {
+        # Initialization code, if needed
+        # Load necessary scripts, define variables, etc.
+    }
+
+    process {
+        # Fetch relevant data
+        # Example: $data = Get-SomeData
+
+        # Process the data to evaluate compliance
+        # Example: $compliantItems = $data | Where-Object { $_.Property -eq 'ExpectedValue' }
+        # Example: $nonCompliantItems = $data | Where-Object { $_.Property -ne 'ExpectedValue' }
+
+        # Prepare failure reasons for non-compliant items
+        $failureReasons = $nonCompliantItems | ForEach-Object {
+            # Example: "Item: $($_.Name) - Reason: Missing expected value"
+        }
+        $failureReasons = $failureReasons -join "`n"
+
+        # Prepare details for non-compliant items
+        $nonCompliantDetails = $nonCompliantItems | ForEach-Object {
+            # Example: "$($_.Name) - Value: $($_.Property)"
+        }
+        $nonCompliantDetails = $nonCompliantDetails -join "`n"
+
+        # Prepare details based on compliance
+        $details = if ($nonCompliantItems) {
+            "Non-Compliant Items: $($nonCompliantItems.Count)`nDetails:`n$nonCompliantDetails"
+        } else {
+            "Compliant Items: $($compliantItems.Count)"
+        }
+
+        # Create and populate the CISAuditResult object
+        $auditResult = [CISAuditResult]::new()
+        $auditResult.Status = if ($nonCompliantItems) { 'Fail' } else { 'Pass' }
+        $auditResult.ELevel = 'E3'  # Modify as needed
+        $auditResult.ProfileLevel = 'L1'  # Modify as needed
+        $auditResult.Rec = '1.1.1'  # Modify as needed
+        $auditResult.RecDescription = "Description of the recommendation"  # Modify as needed
+        $auditResult.CISControlVer = 'v8'  # Modify as needed
+        $auditResult.CISControl = "5.4"  # Modify as needed
+        $auditResult.CISDescription = "Description of the CIS control"  # Modify as needed
+        $auditResult.IG1 = $true  # Modify as needed
+        $auditResult.IG2 = $true  # Modify as needed
+        $auditResult.IG3 = $true  # Modify as needed
+        $auditResult.Result = $nonCompliantItems.Count -eq 0
+        $auditResult.Details = $details
+        $auditResult.FailureReason = if ($nonCompliantItems) {
+            "Non-compliant items:`n$failureReasons"
+        } else {
+            "N/A"
+        }
+
+        # Example output object for a pass result
+        # Status         : Pass
+        # ELevel         : E3
+        # ProfileLevel   : L2
+        # Rec            : 8.1.1
+        # RecDescription : Ensure external file sharing in Teams is enabled for only approved cloud storage services
+        # CISControlVer  : v8
+        # CISControl     : 3.3
+        # CISDescription : Configure Data Access Control Lists
+        # IG1            : True
+        # IG2            : True
+        # IG3            : True
+        # Result         : True
+        # Details        : Compliant Items: 5
+        # FailureReason  : N/A
+
+        # Example output object for a fail result
+        # Status         : Fail
+        # ELevel         : E3
+        # ProfileLevel   : L2
+        # Rec            : 8.1.1
+        # RecDescription : Ensure external file sharing in Teams is enabled for only approved cloud storage services
+        # CISControlVer  : v8
+        # CISControl     : 3.3
+        # CISDescription : Configure Data Access Control Lists
+        # IG1            : True
+        # IG2            : True
+        # IG3            : True
+        # Result         : False
+        # Details        : Non-Compliant Items: 2
+        # FailureReason  : Non-compliant items:`nUsername | Roles | HybridStatus | Missing Licence
+    }
+
+    end {
+        # Return the audit result
+        return $auditResult
+    }
+}

helpers/Get-AdminRoleUserLicense.ps1

@@ -0,0 +1,45 @@
+function Get-AdminRoleUserLicense {
+    [CmdletBinding()]
+    param (
+        [Parameter(Mandatory = $false)]
+        [bool]$SkipGraphConnection = $false
+    )
+
+    # Connect to Microsoft Graph if not skipping connection
+    if (-not $SkipGraphConnection) {
+        Connect-MgGraph -Scopes "Directory.Read.All", "Domain.Read.All", "Policy.Read.All", "Organization.Read.All" -NoWelcome
+    }
+
+    $adminRoleUsers = @()
+    $userIds = @()
+    $adminroles = Get-MgRoleManagementDirectoryRoleDefinition | Where-Object { $_.DisplayName -like "*Admin*" }
+
+    foreach ($role in $adminroles) {
+        $usersInRole = Get-MgRoleManagementDirectoryRoleAssignment -Filter "roleDefinitionId eq '$($role.Id)'"
+
+        foreach ($user in $usersInRole) {
+            $userIds += $user.PrincipalId
+            $userDetails = Get-MgUser -UserId $user.PrincipalId -Property "DisplayName, UserPrincipalName, Id, onPremisesSyncEnabled"
+
+            $adminRoleUsers += [PSCustomObject]@{
+                RoleName = $role.DisplayName
+                UserName = $userDetails.DisplayName
+                UserPrincipalName = $userDetails.UserPrincipalName
+                UserId = $userDetails.Id
+                HybridUser = $userDetails.onPremisesSyncEnabled
+                Licenses = ""  # Placeholder for licenses, to be filled later
+            }
+        }
+    }
+
+    foreach ($userId in $userIds | Select-Object -Unique) {
+        $licenses = Get-MgUserLicenseDetail -UserId $userId
+        $licenseList = ($licenses.SkuPartNumber -join '|')
+
+        $adminRoleUsers | Where-Object { $_.UserId -eq $userId } | ForEach-Object {
+            $_.Licenses = $licenseList
+        }
+    }
+
+    return $adminRoleUsers
+}

source/Classes/CISAuditResult.ps1

@@ -2,6 +2,8 @@ class CISAuditResult {
     [string]$Status
     [string]$ELevel
     [string]$ProfileLevel
+    [bool]$Automated
+    [string]$Connection
     [string]$Rec
     [string]$RecDescription
     [string]$CISControlVer = 'v8'

source/Classes/CISAuthenticationParameters.ps1

@@ -0,0 +1,43 @@
+class CISAuthenticationParameters {
+    [string]$ClientCertThumbPrint
+    [string]$ClientId
+    [string]$TenantId
+    [string]$OnMicrosoftUrl
+    [string]$SpAdminUrl
+
+    # Constructor with validation
+    CISAuthenticationParameters(
+        [string]$ClientCertThumbPrint,
+        [string]$ClientId,
+        [string]$TenantId,
+        [string]$OnMicrosoftUrl,
+        [string]$SpAdminUrl
+    ) {
+        # Validate ClientCertThumbPrint
+        if (-not $ClientCertThumbPrint -or $ClientCertThumbPrint.Length -ne 40 -or $ClientCertThumbPrint -notmatch '^[0-9a-fA-F]{40}$') {
+            throw [ArgumentException]::new("ClientCertThumbPrint must be a 40-character hexadecimal string.")
+        }
+        # Validate ClientId
+        if (-not $ClientId -or $ClientId -notmatch '^[0-9a-fA-F\-]{36}$') {
+            throw [ArgumentException]::new("ClientId must be a valid GUID in the format 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'.")
+        }
+        # Validate TenantId
+        if (-not $TenantId -or $TenantId -notmatch '^[0-9a-fA-F\-]{36}$') {
+            throw [ArgumentException]::new("TenantId must be a valid GUID in the format 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'.")
+        }
+        # Validate OnMicrosoftUrl
+        if (-not $OnMicrosoftUrl -or $OnMicrosoftUrl -notmatch '^[a-zA-Z0-9]+\.onmicrosoft\.com$') {
+            throw [ArgumentException]::new("OnMicrosoftUrl must be in the format 'example.onmicrosoft.com'.")
+        }
+        # Validate SpAdminUrl
+        if (-not $SpAdminUrl -or $SpAdminUrl -notmatch '^https:\/\/[a-zA-Z0-9\-]+\-admin\.sharepoint\.com$') {
+            throw [ArgumentException]::new("SpAdminUrl must be in the format 'https://[name]-admin.sharepoint.com'.")
+        }
+        # Assign validated properties
+        $this.ClientCertThumbPrint = $ClientCertThumbPrint
+        $this.ClientId = $ClientId
+        $this.TenantId = $TenantId
+        $this.OnMicrosoftUrl = $OnMicrosoftUrl
+        $this.SpAdminUrl = $SpAdminUrl
+    }
+}

source/M365FoundationsCISReport.psd1

@@ -33,7 +33,7 @@ Copyright = '(c) 2024 Douglas S. Rios (DrIOSx). All rights reserved.'
 Description = 'Automated assessment of 50 CIS 365 Foundations v3.0.0 benchmark.'
 
 # Minimum version of the Windows PowerShell engine required by this module
-PowerShellVersion = '5.0'
+# PowerShellVersion = '5.1'
 
 # Name of the Windows PowerShell host required by this module
 # PowerShellHostName = ''
@@ -51,7 +51,7 @@ PowerShellVersion = '5.0'
 # ProcessorArchitecture = ''
 
 # Modules that must be imported into the global environment prior to importing this module
-RequiredModules = @()
+# RequiredModules = @()
 
 # Assemblies that must be loaded prior to importing this module
 # RequiredAssemblies = @()
@@ -102,10 +102,10 @@ PrivateData = @{
         LicenseUri = 'https://creativecommons.org/licenses/by-nc-sa/4.0/deed.en'
 
         # A URL to the main website for this project.
-        # ProjectUri = ''
+        ProjectUri = 'https://github.com/CriticalSolutionsNetwork/M365FoundationsCISReport'
 
         # A URL to an icon representing this module.
-        # IconUri = ''
+        IconUri = 'https://csn-source.s3.us-east-2.amazonaws.com/CSN-Icon.png'
 
         # ReleaseNotes of this module
         ReleaseNotes = ''

source/Private/Assert-ModuleAvailability.ps1

@@ -1,33 +1,49 @@
 function Assert-ModuleAvailability {
+    [CmdletBinding()]
+    [OutputType([void]) ]
     param(
         [string]$ModuleName,
         [string]$RequiredVersion,
-        [string]$SubModuleName
+        [string[]]$SubModules = @()
     )
-
-    try {
-        $module = Get-Module -ListAvailable -Name $ModuleName | Where-Object { $_.Version -ge [version]$RequiredVersion }
-
-        if ($null -eq $module) {$auditResult.Profile
-            Write-Host "Installing $ModuleName module..."
-            Install-Module -Name $ModuleName -RequiredVersion $RequiredVersion -Force -AllowClobber -Scope CurrentUser | Out-Null
+    process {
+        try {
+                $module = Get-Module -ListAvailable -Name $ModuleName | Where-Object { $_.Version -ge [version]$RequiredVersion }
+                if ($null -eq $module) {
+                    Write-Verbose "Installing $ModuleName module..."
+                    Install-Module -Name $ModuleName -RequiredVersion $RequiredVersion -Force -AllowClobber -Scope CurrentUser | Out-Null
+                }
+                elseif ($module.Version -lt [version]$RequiredVersion) {
+                    Write-Verbose "Updating $ModuleName module to required version..."
+                    Update-Module -Name $ModuleName -RequiredVersion $RequiredVersion -Force | Out-Null
+                }
+                else {
+                    Write-Verbose "$ModuleName module is already at required version or newer."
+                }
+                if ($ModuleName -eq "Microsoft.Graph") {
+                    # "Preloading Microsoft.Graph assembly to prevent type-loading issues..."
+                    Write-Verbose "Preloading Microsoft.Graph assembly to prevent type-loading issues..."
+                    try {
+                        # Run a harmless cmdlet to preload the assembly
+                        Get-MgGroup -Top 1 -ErrorAction SilentlyContinue | Out-Null
+                    }
+                    catch {
+                        Write-Verbose "Could not preload Microsoft.Graph assembly. Error: $_"
+                    }
+                }
+                if ($SubModules.Count -gt 0) {
+                    foreach ($subModule in $SubModules) {
+                        Write-Verbose "Importing submodule $ModuleName.$subModule..."
+                        Get-Module "$ModuleName.$subModule" | Import-Module -RequiredVersion $RequiredVersion -ErrorAction Stop | Out-Null
+                    }
+                }
+                else {
+                    Write-Verbose "Importing module $ModuleName..."
+                    Import-Module -Name $ModuleName -RequiredVersion $RequiredVersion -ErrorAction Stop -WarningAction SilentlyContinue | Out-Null
+                }
         }
-        elseif ($module.Version -lt [version]$RequiredVersion) {
-            Write-Host "Updating $ModuleName module to required version..."
-            Update-Module -Name $ModuleName -RequiredVersion $RequiredVersion -Force | Out-Null
+        catch {
+            throw "Assert-ModuleAvailability:`n$_"
         }
-        else {
-            Write-Host "$ModuleName module is already at required version or newer."
-        }
-
-        if ($SubModuleName) {
-            Import-Module -Name "$ModuleName.$SubModuleName" -RequiredVersion $RequiredVersion -ErrorAction Stop | Out-Null
-        }
-        else {
-            Import-Module -Name $ModuleName -RequiredVersion $RequiredVersion -ErrorAction Stop | Out-Null
-        }
-    }
-    catch {
-        Write-Warning "An error occurred with module $ModuleName`: $_"
     }
 }

source/Private/Connect-M365Suite.ps1

@@ -1,56 +1,145 @@
 function Connect-M365Suite {
+    [OutputType([void])]
     [CmdletBinding()]
     param (
-        # Parameter to specify the SharePoint Online Tenant Admin URL
+        [Parameter(Mandatory = $false)]
+        [string]$TenantAdminUrl,
+
+        [Parameter(Mandatory = $false)]
+        [CISAuthenticationParameters]$AuthParams,
+
         [Parameter(Mandatory)]
-        [string]$TenantAdminUrl
+        [string[]]$RequiredConnections,
+
+        [Parameter(Mandatory = $false)]
+        [switch]$SkipConfirmation
     )
-$VerbosePreference = "SilentlyContinue"
+
+    $VerbosePreference = if ($SkipConfirmation) { 'SilentlyContinue' } else { 'Continue' }
+    $tenantInfo = @()
+    $connectedServices = @()
+
     try {
-
-        # Attempt to connect to Azure Active Directory
-        Write-Host "Connecting to Azure Active Directory..." -ForegroundColor Cyan
-        Connect-AzureAD | Out-Null
-        Write-Host "Successfully connected to Azure Active Directory." -ForegroundColor Green
-
-        # Attempt to connect to Exchange Online
-        Write-Host "Connecting to Exchange Online..." -ForegroundColor Cyan
-        Connect-ExchangeOnline | Out-Null
-        Write-Host "Successfully connected to Exchange Online." -ForegroundColor Green
-        try {
-            # Attempt to connect to Microsoft Graph with specified scopes
-            Write-Host "Connecting to Microsoft Graph with scopes: Directory.Read.All, Domain.Read.All, Policy.Read.All, Organization.Read.All" -ForegroundColor Cyan
-            Connect-MgGraph -Scopes "Directory.Read.All", "Domain.Read.All", "Policy.Read.All", "Organization.Read.All" -NoWelcome | Out-Null
-            Write-Host "Successfully connected to Microsoft Graph with specified scopes." -ForegroundColor Green
-        }
-        catch {
-            Write-Host "Failed to connect o MgGraph, attempting device auth." -ForegroundColor Yellow
-            # Attempt to connect to Microsoft Graph with specified scopes
-            Write-Host "Connecting to Microsoft Graph using device auth with scopes: Directory.Read.All, Domain.Read.All, Policy.Read.All, Organization.Read.All" -ForegroundColor Cyan
-            Connect-MgGraph -Scopes "Directory.Read.All", "Domain.Read.All", "Policy.Read.All", "Organization.Read.All" -UseDeviceCode -NoWelcome | Out-Null
-            Write-Host "Successfully connected to Microsoft Graph with specified scopes." -ForegroundColor Green
+        if ($RequiredConnections -contains 'Microsoft Graph' -or $RequiredConnections -contains 'EXO | Microsoft Graph') {
+            try {
+                Write-Verbose 'Connecting to Microsoft Graph...'
+                if ($AuthParams) {
+                    Connect-MgGraph -CertificateThumbprint $AuthParams.ClientCertThumbPrint -AppId $AuthParams.ClientId -TenantId $AuthParams.TenantId -NoWelcome | Out-Null
+                }
+                else {
+                    Connect-MgGraph -Scopes 'Directory.Read.All', 'Domain.Read.All', 'Policy.Read.All', 'Organization.Read.All' -NoWelcome | Out-Null
+                }
+                $graphOrgDetails = Get-MgOrganization
+                $tenantInfo += [PSCustomObject]@{
+                    Service    = 'Microsoft Graph'
+                    TenantName = $graphOrgDetails.DisplayName
+                    TenantID   = $graphOrgDetails.Id
+                }
+                $connectedServices += 'Microsoft Graph'
+                Write-Verbose 'Successfully connected to Microsoft Graph.'
+            }
+            catch {
+                throw "Failed to connect to Microsoft Graph: $($_.Exception.Message)"
+            }
         }
 
-        # Validate SharePoint Online Tenant Admin URL
-        if (-not $TenantAdminUrl) {
-            throw "SharePoint Online Tenant Admin URL is required."
+        if ($RequiredConnections -contains 'EXO' -or $RequiredConnections -contains 'AzureAD | EXO' -or $RequiredConnections -contains 'Microsoft Teams | EXO' -or $RequiredConnections -contains 'EXO | Microsoft Graph') {
+            try {
+                Write-Verbose 'Connecting to Exchange Online...'
+                if ($AuthParams) {
+                    Connect-ExchangeOnline -AppId $AuthParams.ClientId -CertificateThumbprint $AuthParams.ClientCertThumbPrint -Organization $AuthParams.OnMicrosoftUrl -ShowBanner:$false | Out-Null
+                }
+                else {
+                    Connect-ExchangeOnline -ShowBanner:$false | Out-Null
+                }
+                $exoTenant = (Get-OrganizationConfig).Identity
+                $tenantInfo += [PSCustomObject]@{
+                    Service    = 'Exchange Online'
+                    TenantName = $exoTenant
+                    TenantID   = 'N/A'
+                }
+                $connectedServices += 'EXO'
+                Write-Verbose 'Successfully connected to Exchange Online.'
+            }
+            catch {
+                throw "Failed to connect to Exchange Online: $($_.Exception.Message)"
+            }
         }
 
-        # Attempt to connect to SharePoint Online
-        Write-Host "Connecting to SharePoint Online..." -ForegroundColor Cyan
-        Connect-SPOService -Url $TenantAdminUrl | Out-Null
-        Write-Host "Successfully connected to SharePoint Online." -ForegroundColor Green
+        if ($RequiredConnections -contains 'SPO') {
+            try {
+                Write-Verbose 'Connecting to SharePoint Online...'
+                if ($AuthParams) {
+                    Connect-PnPOnline -Url $AuthParams.SpAdminUrl -ClientId $AuthParams.ClientId -Tenant $AuthParams.OnMicrosoftUrl -Thumbprint $AuthParams.ClientCertThumbPrint | Out-Null
+                }
+                else {
+                    Connect-SPOService -Url $TenantAdminUrl | Out-Null
+                }
+                $tenantName = if ($AuthParams) {
+                    (Get-PnPSite).Url
+                }
+                else {
+                    # Supress output from Get-SPOSite for powerautomate to avoid errors
+                    [void]($sites =  Get-SPOSite -Limit All)
+                    # Get the URL from the first site collection
+                    $url = $sites[0].Url
+                    # Use regex to extract the base URL up to the .com portion
+                    $baseUrl = [regex]::Match($url, 'https://[^/]+.com').Value
+                    # Output the base URL
+                    $baseUrl
+                }
+                $tenantInfo += [PSCustomObject]@{
+                    Service    = 'SharePoint Online'
+                    TenantName = $tenantName
+                }
+                $connectedServices += 'SPO'
+                Write-Verbose 'Successfully connected to SharePoint Online.'
+            }
+            catch {
+                throw "Failed to connect to SharePoint Online: $($_.Exception.Message)"
+            }
+        }
 
-        # Attempt to connect to Microsoft Teams
-        Write-Host "Connecting to Microsoft Teams..." -ForegroundColor Cyan
-        Connect-MicrosoftTeams | Out-Null
-        Write-Host "Successfully connected to Microsoft Teams." -ForegroundColor Green
+        if ($RequiredConnections -contains 'Microsoft Teams' -or $RequiredConnections -contains 'Microsoft Teams | EXO') {
+            try {
+                Write-Verbose 'Connecting to Microsoft Teams...'
+                if ($AuthParams) {
+                    Connect-MicrosoftTeams -TenantId $AuthParams.TenantId -CertificateThumbprint $AuthParams.ClientCertThumbPrint -ApplicationId $AuthParams.ClientId | Out-Null
+                }
+                else {
+                    Connect-MicrosoftTeams | Out-Null
+                }
+                $teamsTenantDetails = Get-CsTenant
+                $tenantInfo += [PSCustomObject]@{
+                    Service    = 'Microsoft Teams'
+                    TenantName = $teamsTenantDetails.DisplayName
+                    TenantID   = $teamsTenantDetails.TenantId
+                }
+                $connectedServices += 'Microsoft Teams'
+                Write-Verbose 'Successfully connected to Microsoft Teams.'
+            }
+            catch {
+                throw "Failed to connect to Microsoft Teams: $($_.Exception.Message)"
+            }
+        }
+
+        if (-not $SkipConfirmation) {
+            Write-Verbose 'Connected to the following tenants:'
+            foreach ($tenant in $tenantInfo) {
+                Write-Verbose "Service: $($tenant.Service) | Tenant: $($tenant.TenantName)"
+            }
+            $confirmation = Read-Host 'Do you want to proceed with these connections? (Y/N)'
+            if ($confirmation -notlike 'Y') {
+                Disconnect-M365Suite -RequiredConnections $connectedServices
+                throw 'User aborted connection setup.'
+            }
+        }
     }
     catch {
-        $VerbosePreference = "Continue"
-        Write-Host "There was an error establishing one or more connections: $_" -ForegroundColor Red
-        throw $_
+        $VerbosePreference = 'Continue'
+        throw "Connection failed: $($_.Exception.Message)"
     }
-    $VerbosePreference = "Continue"
-}
-
+    finally {
+        $VerbosePreference = 'Continue'
+    }
+}

source/Private/Disconnect-M365Suite.ps1

@@ -1,39 +1,65 @@
 function Disconnect-M365Suite {
+    [OutputType([void])]
+    param (
+        [Parameter(Mandatory)]
+        [string[]]$RequiredConnections
+    )
+
     # Clean up sessions
     try {
-        Write-Host "Disconnecting from Exchange Online..." -ForegroundColor Green
-        Disconnect-ExchangeOnline -Confirm:$false | Out-Null
+        if ($RequiredConnections -contains "EXO" -or $RequiredConnections -contains "AzureAD | EXO" -or $RequiredConnections -contains "Microsoft Teams | EXO") {
+            Write-Verbose "Disconnecting from Exchange Online..."
+            Disconnect-ExchangeOnline -Confirm:$false | Out-Null
+        }
     }
     catch {
         Write-Warning "Failed to disconnect from Exchange Online: $_"
     }
+
     try {
-        Write-Host "Disconnecting from Azure AD..." -ForegroundColor Green
-        Disconnect-AzureAD | Out-Null
+        if ($RequiredConnections -contains "AzureAD" -or $RequiredConnections -contains "AzureAD | EXO") {
+            Write-Verbose "Disconnecting from Azure AD..."
+            Disconnect-AzureAD | Out-Null
+        }
     }
     catch {
         Write-Warning "Failed to disconnect from Azure AD: $_"
     }
+
     try {
-        Write-Host "Disconnecting from Microsoft Graph..." -ForegroundColor Green
-        Disconnect-MgGraph | Out-Null
+        if ($RequiredConnections -contains "Microsoft Graph") {
+            Write-Verbose "Disconnecting from Microsoft Graph..."
+            Disconnect-MgGraph | Out-Null
+        }
     }
     catch {
         Write-Warning "Failed to disconnect from Microsoft Graph: $_"
     }
+
     try {
-        Write-Host "Disconnecting from SharePoint Online..." -ForegroundColor Green
-        Disconnect-SPOService | Out-Null
+        if ($RequiredConnections -contains "SPO") {
+            if (($script:PnpAuth)) {
+                Write-Verbose "Disconnecting from PnPOnline..."
+                Disconnect-PnPOnline | Out-Null
+            }
+            else {
+                Write-Verbose "Disconnecting from SharePoint Online..."
+                Disconnect-SPOService | Out-Null
+            }
+        }
     }
     catch {
         Write-Warning "Failed to disconnect from SharePoint Online: $_"
     }
+
     try {
-        Write-Host "Disconnecting from Microsoft Teams..." -ForegroundColor Green
-        Disconnect-MicrosoftTeams | Out-Null
+        if ($RequiredConnections -contains "Microsoft Teams" -or $RequiredConnections -contains "Microsoft Teams | EXO") {
+            Write-Verbose "Disconnecting from Microsoft Teams..."
+            Disconnect-MicrosoftTeams | Out-Null
+        }
     }
     catch {
         Write-Warning "Failed to disconnect from Microsoft Teams: $_"
     }
-    Write-Host "All sessions have been disconnected." -ForegroundColor Green
+    Write-Verbose "All necessary sessions have been disconnected."
 }

source/Private/Format-RequiredModuleList.ps1

@@ -0,0 +1,19 @@
+function Format-RequiredModuleList {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param (
+        [Parameter(Mandatory = $true)]
+        [System.Object[]]$RequiredModules
+    )
+
+    $requiredModulesFormatted = ""
+    foreach ($module in $RequiredModules) {
+        if ($module.SubModules -and $module.SubModules.Count -gt 0) {
+            $subModulesFormatted = $module.SubModules -join ', '
+            $requiredModulesFormatted += "$($module.ModuleName) (SubModules: $subModulesFormatted), "
+        } else {
+            $requiredModulesFormatted += "$($module.ModuleName), "
+        }
+    }
+    return $requiredModulesFormatted.TrimEnd(", ")
+}

source/Private/Get-Action.ps1

@@ -0,0 +1,177 @@
+function Get-Action {
+    [CmdletBinding(DefaultParameterSetName = "GetDictionaries")]
+    param (
+        [Parameter(Position = 0, ParameterSetName = "GetDictionaries")]
+        [switch]$Dictionaries,
+
+        [Parameter(Position = 0, ParameterSetName = "ConvertActions")]
+        [string[]]$Actions,
+
+        [Parameter(Position = 1, Mandatory = $true, ParameterSetName = "ConvertActions")]
+        [ValidateSet("Admin", "Delegate", "Owner")]
+        [string]$ActionType,
+
+        [Parameter(Position = 2, Mandatory = $true, ParameterSetName = "ConvertActions")]
+        [Parameter(Position = 2, Mandatory = $true, ParameterSetName = "ReverseActions")]
+        [Parameter(Position = 1, Mandatory = $true, ParameterSetName = "GetDictionaries")]
+        [ValidateSet("6.1.2", "6.1.3")]
+        [string]$Version = "6.1.2",
+
+        [Parameter(Position = 0, ParameterSetName = "ReverseActions")]
+        [string[]]$AbbreviatedActions,
+
+        [Parameter(Position = 1, Mandatory = $true, ParameterSetName = "ReverseActions")]
+        [ValidateSet("Admin", "Delegate", "Owner")]
+        [string]$ReverseActionType
+    )
+
+    $Dictionary = @{
+        "6.1.2" = @{
+            AdminActions = @{
+                ApplyRecord              = 'AR'
+                Copy                     = 'CP'
+                Create                   = 'CR'
+                FolderBind               = 'FB'
+                HardDelete               = 'HD'
+                Move                     = 'MV'
+                MoveToDeletedItems       = 'MTDI'
+                SendAs                   = 'SA'
+                SendOnBehalf             = 'SOB'
+                SoftDelete               = 'SD'
+                Update                   = 'UP'
+                UpdateCalendarDelegation = 'UCD'
+                UpdateFolderPermissions  = 'UFP'
+                UpdateInboxRules         = 'UIR'
+            }
+            DelegateActions = @{
+                ApplyRecord             = 'AR'
+                Create                  = 'CR'
+                FolderBind              = 'FB'
+                HardDelete              = 'HD'
+                Move                    = 'MV'
+                MoveToDeletedItems      = 'MTDI'
+                SendAs                  = 'SA'
+                SendOnBehalf            = 'SOB'
+                SoftDelete              = 'SD'
+                Update                  = 'UP'
+                UpdateFolderPermissions = 'UFP'
+                UpdateInboxRules        = 'UIR'
+            }
+            OwnerActions = @{
+                ApplyRecord              = 'AR'
+                Create                   = 'CR'
+                HardDelete               = 'HD'
+                MailboxLogin             = 'ML'
+                Move                     = 'MV'
+                MoveToDeletedItems       = 'MTDI'
+                SoftDelete               = 'SD'
+                Update                   = 'UP'
+                UpdateCalendarDelegation = 'UCD'
+                UpdateFolderPermissions  = 'UFP'
+                UpdateInboxRules         = 'UIR'
+            }
+        }
+        "6.1.3" = @{
+            AdminActions = @{
+                ApplyRecord              = 'AR'
+                Copy                     = 'CP'
+                Create                   = 'CR'
+                FolderBind               = 'FB'
+                HardDelete               = 'HD'
+                MailItemsAccessed        = 'MIA'
+                Move                     = 'MV'
+                MoveToDeletedItems       = 'MTDI'
+                SendAs                   = 'SA'
+                SendOnBehalf             = 'SOB'
+                Send                     = 'SD'
+                SoftDelete               = 'SD'
+                Update                   = 'UP'
+                UpdateCalendarDelegation = 'UCD'
+                UpdateFolderPermissions  = 'UFP'
+                UpdateInboxRules         = 'UIR'
+            }
+            DelegateActions = @{
+                ApplyRecord             = 'AR'
+                Create                  = 'CR'
+                FolderBind              = 'FB'
+                HardDelete              = 'HD'
+                MailItemsAccessed       = 'MIA'
+                Move                    = 'MV'
+                MoveToDeletedItems      = 'MTDI'
+                SendAs                  = 'SA'
+                SendOnBehalf            = 'SOB'
+                SoftDelete              = 'SD'
+                Update                  = 'UP'
+                UpdateFolderPermissions = 'UFP'
+                UpdateInboxRules        = 'UIR'
+            }
+            OwnerActions = @{
+                ApplyRecord              = 'AR'
+                Create                   = 'CR'
+                HardDelete               = 'HD'
+                MailboxLogin             = 'ML'
+                MailItemsAccessed        = 'MIA'
+                Move                     = 'MV'
+                MoveToDeletedItems       = 'MTDI'
+                Send                     = 'SD'
+                SoftDelete               = 'SD'
+                Update                   = 'UP'
+                UpdateCalendarDelegation = 'UCD'
+                UpdateFolderPermissions  = 'UFP'
+                UpdateInboxRules         = 'UIR'
+            }
+        }
+    }
+
+    switch ($PSCmdlet.ParameterSetName) {
+        "GetDictionaries" {
+            return $Dictionary[$Version]
+        }
+        "ConvertActions" {
+            try {
+                $Dictionary = $Dictionary[$Version]
+                $actionDictionary = switch ($ActionType) {
+                    "Admin"    { $Dictionary.AdminActions }
+                    "Delegate" { $Dictionary.DelegateActions }
+                    "Owner"    { $Dictionary.OwnerActions }
+                }
+
+                $abbreviatedActions = @()
+                foreach ($action in $Actions) {
+                    if ($actionDictionary.ContainsKey($action)) {
+                        $abbreviatedActions += $actionDictionary[$action]
+                    }
+                }
+                return $abbreviatedActions
+            }
+            catch {
+                throw $_
+            }
+
+        }
+        "ReverseActions" {
+            try {
+                $Dictionary = $Dictionary[$Version]
+                $reverseDictionary = @{}
+                $originalDictionary = switch ($ReverseActionType) {
+                    "Admin"    { $Dictionary.AdminActions }
+                    "Delegate" { $Dictionary.DelegateActions }
+                    "Owner"    { $Dictionary.OwnerActions }
+                }
+                foreach ($key in $originalDictionary.Keys) {
+                    $reverseDictionary[$originalDictionary[$key]] = $key
+                }
+                $fullNames = @()
+                foreach ($abbrAction in $AbbreviatedActions) {
+                    if ($reverseDictionary.ContainsKey($abbrAction)) {
+                        $fullNames += $reverseDictionary[$abbrAction]
+                    }
+                }
+                return $fullNames
+            }
+            catch {
+                throw $_
+            }
+        }
+    }
+}

source/Private/Get-AdminRoleUserAndAssignment.ps1

@@ -0,0 +1,38 @@
+function Get-AdminRoleUserAndAssignment {
+    [CmdletBinding()]
+    param ()
+
+    $result = @{}
+
+    # Get the DisplayNames of all admin roles
+    $adminRoleNames = (Get-MgDirectoryRole | Where-Object { $null -ne $_.RoleTemplateId }).DisplayName
+
+    # Get Admin Roles
+    $adminRoles = Get-MgRoleManagementDirectoryRoleDefinition | Where-Object { ($adminRoleNames -contains $_.DisplayName) -and ($_.DisplayName -ne "Directory Synchronization Accounts") }
+
+    foreach ($role in $adminRoles) {
+        Write-Verbose "Processing role: $($role.DisplayName)"
+        $roleAssignments = Get-MgRoleManagementDirectoryRoleAssignment -Filter "roleDefinitionId eq '$($role.Id)'"
+
+        foreach ($assignment in $roleAssignments) {
+            Write-Verbose "Processing role assignment for principal ID: $($assignment.PrincipalId)"
+            $userDetails = Get-MgUser -UserId $assignment.PrincipalId -Property "DisplayName, UserPrincipalName, Id, OnPremisesSyncEnabled" -ErrorAction SilentlyContinue
+
+            if ($userDetails) {
+                Write-Verbose "Retrieved user details for: $($userDetails.UserPrincipalName)"
+                $licenses = Get-MgUserLicenseDetail -UserId $assignment.PrincipalId -ErrorAction SilentlyContinue
+
+                if (-not $result[$role.DisplayName]) {
+                    $result[$role.DisplayName] = @()
+                }
+                $result[$role.DisplayName] += [PSCustomObject]@{
+                    AssignmentId = $assignment.Id
+                    UserDetails  = $userDetails
+                    Licenses     = $licenses
+                }
+            }
+        }
+    }
+
+    return $result
+}

source/Private/Get-AuditMailboxDetail.ps1

@@ -0,0 +1,33 @@
+function Get-AuditMailboxDetail {
+    [cmdletBinding()]
+    param (
+        [Parameter(Mandatory = $true)]
+        [String]$Details,
+        [Parameter(Mandatory = $true)]
+        [String]$Version
+    )
+    process {
+        switch ($Version) {
+            "6.1.2" { [string]$VersionText = "No M365 E3 licenses found."}
+            "6.1.3" { [string]$VersionText = "No M365 E5 licenses found."}
+        }
+        if ($details -ne $VersionText ) {
+            $csv = $details | ConvertFrom-Csv -Delimiter '|'
+        }
+        else {
+            $csv = $null
+        }
+        if ($null -ne $csv) {
+            foreach ($row in $csv) {
+                $row.AdminActionsMissing = (Get-Action -AbbreviatedActions $row.AdminActionsMissing.Split(',') -ReverseActionType Admin -Version $Version) -join ','
+                $row.DelegateActionsMissing = (Get-Action -AbbreviatedActions $row.DelegateActionsMissing.Split(',') -ReverseActionType Delegate -Version $Version ) -join ','
+                $row.OwnerActionsMissing = (Get-Action -AbbreviatedActions $row.OwnerActionsMissing.Split(',') -ReverseActionType Owner -Version $Version ) -join ','
+            }
+            $newObjectDetails = $csv
+        }
+        else {
+            $newObjectDetails = $details
+        }
+        return $newObjectDetails
+    }
+}

source/Private/Get-CISAadOutput.ps1

@@ -0,0 +1,39 @@
+<#
+    .SYNOPSIS
+        This is a sample Private function only visible within the module.
+    .DESCRIPTION
+        This sample function is not exported to the module and only return the data passed as parameter.
+    .EXAMPLE
+        $null = Get-Get-CISAadOutput -PrivateData 'NOTHING TO SEE HERE'
+    .PARAMETER PrivateData
+        The PrivateData parameter is what will be returned without transformation.
+#>
+function Get-CISAadOutput {
+    [cmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [String]$Rec
+    )
+    begin {
+        # Begin Block #
+    <#
+        # Tests
+        1.2.2
+        # Test number
+        $testNumbers ="1.2.2"
+    #>
+    }
+    process {
+        switch ($Rec) {
+            '1.2.2' {
+                # Test-BlockSharedMailboxSignIn.ps1
+                $users = Get-AzureADUser
+            }
+            default { throw "No match found for test: $Rec" }
+        }
+    }
+    end {
+        Write-Verbose "Get-CISAadOutput: Retuning data for Rec: $Rec"
+        return $users
+    }
+} # end function Get-CISAadOutput

source/Private/Get-CISExoOutput.ps1

@@ -0,0 +1,491 @@
+<#
+    .SYNOPSIS
+        This is a sample Private function only visible within the module.
+    .DESCRIPTION
+        This sample function is not exported to the module and only return the data passed as parameter.
+    .EXAMPLE
+        $null = Get-CISExoOutput -PrivateData 'NOTHING TO SEE HERE'
+    .PARAMETER PrivateData
+        The PrivateData parameter is what will be returned without transformation.
+#>
+function Get-CISExoOutput {
+    [cmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [String]$Rec
+    )
+    begin {
+        # Begin Block #
+        <#
+        # Tests
+        1.2.2
+        1.3.3
+        1.3.6
+        2.1.1
+        2.1.2
+        2.1.3
+        2.1.4
+        2.1.5
+        2.1.6
+        2.1.7
+        2.1.9
+        3.1.1
+        6.1.1
+        6.1.2
+        6.1.3
+        6.2.1
+        6.2.2
+        6.2.3
+        6.3.1
+        6.5.1
+        6.5.2
+        6.5.3
+        8.6.1
+        # Test number array
+        $testNumbers = @('1.2.2', '1.3.3', '1.3.6', '2.1.1', '2.1.2', '2.1.3', '2.1.4', '2.1.5', '2.1.6', '2.1.7', '2.1.9', '3.1.1', '6.1.1', '6.1.2', '6.1.3', '6.2.1', '6.2.2', '6.2.3', '6.3.1', '6.5.1', '6.5.2', '6.5.3', '8.6.1')
+    #>
+    }
+    process {
+        try {
+            Write-Verbose "Get-CISExoOutput: Retuning data for Rec: $Rec"
+            switch ($Rec) {
+                '1.2.2' {
+                    # Test-BlockSharedMailboxSignIn.ps1
+                    $MBX = Get-EXOMailbox -RecipientTypeDetails SharedMailbox
+                    # [object[]]
+                    # $MBX mock object:
+                    <#
+                        $MBX = @(
+                            [PSCustomObject]@{
+                                UserPrincipalName = "SMBuser1@domain.com"
+                                ExternalDirectoryObjectId = "123e4567-e89b-12d3-a456-426614174000"
+                            },
+                            [PSCustomObject]@{
+                                UserPrincipalName = "SMBuser2@domain.com"
+                                ExternalDirectoryObjectId = "987e6543-21ba-12d3-a456-426614174000"
+                            },
+                            [PSCustomObject]@{
+                                UserPrincipalName = "SMBuser3@domain.com"
+                                ExternalDirectoryObjectId = "abcddcba-98fe-76dc-a456-426614174000"
+                            }
+                        )
+                    #>
+                    return $MBX.ExternalDirectoryObjectId
+                }
+                '1.3.3' {
+                    # Test-ExternalSharingCalendars.ps1
+                    # Step: Retrieve sharing policies related to calendar sharing
+                    # $sharingPolicies Mock Object
+                    <#
+                        $sharingPolicies = [PSCustomObject]@{
+                            Name = "Default Sharing Policy"
+                            Domains = @("Anonymous:CalendarSharingFreeBusySimple")
+                            Enabled = $true
+                            Default = $true
+                        }
+                    #>
+                    $sharingPolicies = Get-SharingPolicy | Where-Object { $_.Domains -like '*CalendarSharing*' }
+                    # [psobject[]]
+                    return $sharingPolicies
+                }
+                '1.3.6' {
+                    # Test-CustomerLockbox.ps1
+                    # Step: Retrieve the organization configuration (Condition C: Pass/Fail)
+                    # $orgConfig Mock Object:
+                    <#
+                        # return $orgConfig
+                        $orgConfig = [PSCustomObject]@{
+                            CustomerLockBoxEnabled = $true
+                        }
+                    #>
+                    $orgConfig = Get-OrganizationConfig | Select-Object CustomerLockBoxEnabled
+                    $customerLockboxEnabled = $orgConfig.CustomerLockBoxEnabled
+                    # [bool]
+                    return $customerLockboxEnabled
+                }
+                '2.1.1' {
+                    # Test-SafeLinksOfficeApps.ps1
+                    if (Get-Command Get-SafeLinksPolicy -ErrorAction SilentlyContinue) {
+                        # 2.1.1 (L2) Ensure Safe Links for Office Applications is Enabled
+                        # Retrieve all Safe Links policies
+                        # $policies Mock Object:
+                        <#
+                            $policies = @(
+                                [PSCustomObject]@{
+                                    Name = "PolicyOne"
+                                    EnableSafeLinksForEmail = $true
+                                    EnableSafeLinksForTeams = $true
+                                    EnableSafeLinksForOffice = $true
+                                    TrackClicks = $true
+                                    AllowClickThrough = $false
+                                },
+                                [PSCustomObject]@{
+                                    Name = "PolicyTwo"
+                                    EnableSafeLinksForEmail = $true
+                                    EnableSafeLinksForTeams = $true
+                                    EnableSafeLinksForOffice = $true
+                                    TrackClicks = $true
+                                    AllowClickThrough = $true
+                                },
+                                [PSCustomObject]@{
+                                    Name = "PolicyThree"
+                                    EnableSafeLinksForEmail = $true
+                                    EnableSafeLinksForTeams = $true
+                                    EnableSafeLinksForOffice = $true
+                                    TrackClicks = $true
+                                    AllowClickThrough = $false
+                                }
+                            )
+                        #>
+                        $policies = Get-SafeLinksPolicy
+                        # Initialize the details collection
+                        $misconfiguredDetails = @()
+                        foreach ($policy in $policies) {
+                            # Get the detailed configuration of each policy
+                            $policyDetails = $policy #Get-SafeLinksPolicy -Identity $policy.Name
+                            # Check each required property and record failures
+                            # Condition A: Checking policy settings
+                            $failures = @()
+                            if ($policyDetails.EnableSafeLinksForEmail -ne $true) { $failures += "EnableSafeLinksForEmail: False" } # Email: On
+                            if ($policyDetails.EnableSafeLinksForTeams -ne $true) { $failures += "EnableSafeLinksForTeams: False" } # Teams: On
+                            if ($policyDetails.EnableSafeLinksForOffice -ne $true) { $failures += "EnableSafeLinksForOffice: False" } # Office 365 Apps: On
+                            if ($policyDetails.TrackClicks -ne $true) { $failures += "TrackClicks: False" } # Click protection settings: On
+                            if ($policyDetails.AllowClickThrough -ne $false) { $failures += "AllowClickThrough: True" } # Do not track when users click safe links: Off
+                            # Only add details for policies that have misconfigurations
+                            if ($failures.Count -gt 0) {
+                                $misconfiguredDetails += "Policy: $($policy.Name); Failures: $($failures -join ', ')"
+                            }
+                        }
+                        # [object[]]
+                        return $misconfiguredDetails
+                    }
+                    else {
+                        return 1
+                    }
+                }
+                '2.1.2' {
+                    # Test-CommonAttachmentFilter.ps1
+                    # 2.1.2 (L1) Ensure the Common Attachment Types Filter is enabled
+                    # Condition A: The Common Attachment Types Filter is enabled in the Microsoft 365 Security & Compliance Center.
+                    # Condition B: Using Exchange Online PowerShell, verify that the `EnableFileFilter` property of the default malware filter policy is set to `True`.
+                    # Retrieve the attachment filter policy
+                    # $attachmentFilter Mock Object
+                    <#
+                        $attachmentFilter = [PSCustomObject]@{
+                            EnableFileFilter = $true
+                        }
+                    #>
+                    $attachmentFilter = Get-MalwareFilterPolicy -Identity Default | Select-Object EnableFileFilter
+                    $result = $attachmentFilter.EnableFileFilter
+                    # [bool]
+                    return $result
+                }
+                '2.1.3' {
+                    # Test-NotifyMalwareInternal.ps1
+                    # 2.1.3 Ensure notifications for internal users sending malware is Enabled
+                    # Retrieve all 'Custom' malware filter policies and check notification settings
+                    # $malwareNotifications Mock Object
+                    <#
+                        $malwareNotifications = @(
+                            [PSCustomObject]@{
+                                Identity = "Default"
+                                EnableInternalSenderAdminNotifications = $true
+                                RecommendedPolicyType = "Custom"
+                            },
+                            [PSCustomObject]@{
+                                Identity = "Anti-malware-Policy"
+                                EnableInternalSenderAdminNotifications = $true
+                                RecommendedPolicyType = "Custom"
+                            }
+                        )
+                    #>
+                    $malwareNotifications = Get-MalwareFilterPolicy | Where-Object { $_.RecommendedPolicyType -eq 'Custom' }
+                    # [object[]]
+                    return $malwareNotifications
+                }
+                '2.1.4' {
+                    # Test-SafeAttachmentsPolicy.ps1
+                    if (Get-Command Get-SafeAttachmentPolicy -ErrorAction SilentlyContinue) {
+                        # Retrieve all Safe Attachment policies where Enable is set to True
+                        # Check if ErrorAction needed below
+                        # $safeAttachmentPolicies Mock Object:
+                        <#
+                            $safeAttachmentPolicies = @(
+                                [PSCustomObject]@{
+                                    Policy        = "Strict Preset Security Policy"
+                                    Action        = "Block"
+                                    QuarantineTag = "AdminOnlyAccessPolicy"
+                                    Redirect      = $false
+                                    Enabled       = $true
+                                }
+                            )
+                        #>
+                        $safeAttachmentPolicies = Get-SafeAttachmentPolicy -ErrorAction SilentlyContinue | Where-Object { $_.Enable -eq $true }
+                        $safeAttachmentRules = Get-SafeAttachmentRule
+                        # [object[]]
+                        return $safeAttachmentPolicies, $safeAttachmentRules
+                        else {
+                            return 1,1
+                        }
+                    }
+                }
+                '2.1.5' {
+                    # Test-SafeAttachmentsTeams.ps1
+                    if (Get-Command Get-AtpPolicyForO365 -ErrorAction SilentlyContinue) {
+                        # 2.1.5 (L2) Ensure Safe Attachments for SharePoint, OneDrive, and Microsoft Teams is Enabled
+                        # Retrieve the ATP policies for Office 365 and check Safe Attachments settings
+                        $atpPolicies = Get-AtpPolicyForO365
+                        # Check if the required ATP policies are enabled
+                        # $atpPolicyResult Mock Object:
+                        <#
+                            $atpPolicyResult = @(
+                                [PSCustomObject]@{
+                                    Name                   = "Default"
+                                    EnableATPForSPOTeamsODB = $true
+                                    EnableSafeDocs         = $true
+                                    AllowSafeDocsOpen      = $false
+                                }
+                            )
+                        #>
+                        $atpPolicyResult = $atpPolicies | Where-Object {
+                            $_.EnableATPForSPOTeamsODB -eq $true -and
+                            $_.EnableSafeDocs -eq $true -and
+                            $_.AllowSafeDocsOpen -eq $false
+                        }
+                        # [psobject[]]
+                        return $atpPolicyResult
+                    }
+                    else {
+                        return 1
+                    }
+                }
+                '2.1.6' {
+                    # Test-SpamPolicyAdminNotify.ps1
+                    # Retrieve the hosted outbound spam filter policies
+                    # $spamPolicies Mock Object:
+                    <#
+                        # Mock data representing multiple spam filter policies
+                        $spamPolicies = @(
+                            [PSCustomObject]@{
+                                Name                                       = "Default"
+                                IsDefault                                  = $true
+                                NotifyOutboundSpam                         = $true
+                                BccSuspiciousOutboundMail                  = $true
+                                NotifyOutboundSpamRecipients               = "admin@example.com"
+                                BccSuspiciousOutboundAdditionalRecipients  = "bccadmin@example.com"
+                            },
+                            [PSCustomObject]@{
+                                Name                                       = "Custom Policy 1"
+                                IsDefault                                  = $false
+                                NotifyOutboundSpam                         = $false
+                                BccSuspiciousOutboundMail                  = $true
+                                NotifyOutboundSpamRecipients               = ""
+                                BccSuspiciousOutboundAdditionalRecipients  = ""
+                            },
+                            [PSCustomObject]@{
+                                Name                                       = "Custom Policy 2"
+                                IsDefault                                  = $false
+                                NotifyOutboundSpam                         = $true
+                                BccSuspiciousOutboundMail                  = $false
+                                NotifyOutboundSpamRecipients               = "notify@example.com"
+                                BccSuspiciousOutboundAdditionalRecipients  = "bccnotify@example.com"
+                            }
+                        )
+                    #>
+                    $spamPolicies = Get-HostedOutboundSpamFilterPolicy
+                    return $spamPolicies
+                }
+                '2.1.7' {
+                    # Test-AntiPhishingPolicy.ps1
+                    <#
+                        $antiPhishPolicies = @(
+                            [PSCustomObject]@{
+                                Identity = "Strict Preset Security Policy"
+                                Enabled = $true
+                                PhishThresholdLevel = 4
+                                EnableMailboxIntelligenceProtection = $true
+                                EnableMailboxIntelligence = $true
+                                EnableSpoofIntelligence = $true
+                                TargetedUsersToProtect = "John Doe;jdoe@contoso.net, Jane Does;janedoe@contoso.net"
+                            },
+                            [PSCustomObject]@{
+                                Identity = "Office365 AntiPhish Default"
+                                Enabled = $true
+                                PhishThresholdLevel = 2
+                                EnableMailboxIntelligenceProtection = $true
+                                EnableMailboxIntelligence = $true
+                                EnableSpoofIntelligence = $true
+                                TargetedUsersToProtect = $null  # Assuming it targets all users as it's the default
+                            },
+                            [PSCustomObject]@{
+                                Identity = "Admin"
+                                Enabled = $true
+                                PhishThresholdLevel = 2
+                                EnableMailboxIntelligenceProtection = $true
+                                EnableMailboxIntelligence = $true
+                                EnableSpoofIntelligence = $true
+                                TargetedUsersToProtect = $null  # Assuming it targets all users
+                            },
+                            [PSCustomObject]@{
+                                Identity = "Standard Preset Security Policy"
+                                Enabled = $true
+                                PhishThresholdLevel = 3
+                                EnableMailboxIntelligenceProtection = $true
+                                EnableMailboxIntelligence = $true
+                                EnableSpoofIntelligence = $true
+                                TargetedUsersToProtect = $null  # Assuming it targets all users
+                            }
+                        )
+                    #>
+                    $antiPhishPolicies = Get-AntiPhishPolicy
+                    return $antiPhishPolicies
+                }
+                '2.1.9' {
+                    # Test-EnableDKIM.ps1
+                    # 2.1.9 (L1) Ensure DKIM is enabled for all Exchange Online Domains
+                    # Retrieve DKIM configuration for all domains
+                    $dkimConfig = Get-DkimSigningConfig | Select-Object Domain, Enabled
+                    # [object[]]
+                    return $dkimConfig
+                }
+                '3.1.1' {
+                    # Test-AuditLogSearch.ps1
+                    # 3.1.1 (L1) Ensure Microsoft 365 audit log search is Enabled
+                    # Retrieve the audit log configuration
+                    $auditLogConfig = Get-AdminAuditLogConfig | Select-Object UnifiedAuditLogIngestionEnabled
+                    #
+                    $auditLogResult = $auditLogConfig.UnifiedAuditLogIngestionEnabled
+                    # [bool]
+                    return $auditLogResult
+                }
+                '6.1.1' {
+                    # Test-AuditDisabledFalse.ps1
+                    # 6.1.1 (L1) Ensure 'AuditDisabled' organizationally is set to 'False'
+                    # Retrieve the AuditDisabled configuration (Condition B)
+                    $auditDisabledConfig = Get-OrganizationConfig | Select-Object AuditDisabled
+                    # [bool]
+                    $auditNotDisabled = -not $auditDisabledConfig.AuditDisabled
+                    return $auditNotDisabled
+                }
+                '6.1.2' {
+                    # Test-MailboxAuditingE3.ps1
+                    $mailboxes = Get-EXOMailbox -PropertySets Audit
+                    # [object[]]
+                    return $mailboxes
+                }
+                '6.1.3' {
+                    # Test-MailboxAuditingE5.ps1
+                    $mailboxes = Get-EXOMailbox -PropertySets Audit
+                    # [object[]]
+                    return $mailboxes
+                }
+                '6.2.1' {
+                    # Test-BlockMailForwarding.ps1
+                    # 6.2.1 (L1) Ensure all forms of mail forwarding are blocked and/or disabled
+                    # Step 1: Retrieve the transport rules that redirect messages
+                    $transportRules = Get-TransportRule | Where-Object { $null -ne $_.RedirectMessageTo }
+                    if ($null -eq $transportRules) {
+                        $transportRules = 1
+                    }
+                    # Step 2: Check all anti-spam outbound policies
+                    $outboundSpamPolicies = Get-HostedOutboundSpamFilterPolicy
+                    $nonCompliantSpamPolicies = $outboundSpamPolicies | Where-Object { $_.AutoForwardingMode -ne 'Off' }
+                    return $transportRules, $nonCompliantSpamPolicies
+                }
+                '6.2.2' {
+                    # Test-NoWhitelistDomains.ps1
+                    # 6.2.2 (L1) Ensure mail transport rules do not whitelist specific domains
+                    # Retrieve transport rules that whitelist specific domains
+                    # Condition A: Checking for transport rules that whitelist specific domains
+                    # [object[]]
+                    $whitelistedRules = Get-TransportRule | Where-Object { $_.SetSCL -eq -1 -and $null -ne $_.SenderDomainIs }
+                    return $whitelistedRules
+                }
+                '6.2.3' {
+                    # Test-IdentifyExternalEmail.ps1
+                    # 6.2.3 (L1) Ensure email from external senders is identified
+                    # Retrieve external sender tagging configuration
+                    # [object[]]
+                    $externalInOutlook = Get-ExternalInOutlook
+                    return $externalInOutlook
+                }
+                '6.3.1' {
+                    # Test-RestrictOutlookAddins.ps1
+                    # 6.3.1 (L2) Ensure users installing Outlook add-ins is not allowed
+                    $customPolicyFailures = @()
+                    # Check all mailboxes for custom policies with unallowed add-ins
+                    $roleAssignmentPolicies = Get-EXOMailbox | Select-Object -Unique RoleAssignmentPolicy
+                    if ($roleAssignmentPolicies.RoleAssignmentPolicy) {
+                        foreach ($policy in $roleAssignmentPolicies) {
+                            if ($policy.RoleAssignmentPolicy) {
+                                $rolePolicyDetails = Get-RoleAssignmentPolicy -Identity $policy.RoleAssignmentPolicy
+                                $foundRoles = $rolePolicyDetails.AssignedRoles | Where-Object { $_ -in $relevantRoles }
+                                # Condition B: Using PowerShell, verify that MyCustomApps, MyMarketplaceApps, and MyReadWriteMailboxApps are not assigned to users.
+                                if ($foundRoles) {
+                                    $customPolicyFailures += "Policy: $($policy.RoleAssignmentPolicy): Roles: $($foundRoles -join ', ')"
+                                }
+                            }
+                        }
+                    }
+                    # Check Default Role Assignment Policy
+                    $defaultPolicy = Get-RoleAssignmentPolicy "Default Role Assignment Policy"
+                    return $customPolicyFailures, $defaultPolicy
+                }
+                '6.5.1' {
+                    # Test-ModernAuthExchangeOnline.ps1
+                    # Ensuring the ExchangeOnlineManagement module is available
+                    # 6.5.1 (L1) Ensure modern authentication for Exchange Online is enabled
+                    # Check modern authentication setting in Exchange Online configuration (Condition A and B)
+                    $orgConfig = Get-OrganizationConfig | Select-Object -Property Name, OAuth2ClientProfileEnabled
+                    return $orgConfig
+                }
+                '6.5.2' {
+                    # Test-MailTipsEnabled.ps1
+                    # 6.5.2 (L2) Ensure MailTips are enabled for end users
+                    # Retrieve organization configuration for MailTips settings
+                    # [object]
+                    $orgConfig = Get-OrganizationConfig | Select-Object MailTipsAllTipsEnabled, MailTipsExternalRecipientsTipsEnabled, MailTipsGroupMetricsEnabled, MailTipsLargeAudienceThreshold
+                    return $orgConfig
+                }
+                '6.5.3' {
+                    # Test-RestrictStorageProvidersOutlook.ps1
+                    # 6.5.3 (L2) Ensure additional storage providers are restricted in Outlook on the web
+                    # Retrieve all OwaMailbox policies
+                    # [object[]]
+                    $owaPolicies = Get-OwaMailboxPolicy
+                    return $owaPolicies
+                }
+                '8.6.1' {
+                    # Test-ReportSecurityInTeams.ps1
+                    # 8.6.1 (L1) Ensure users can report security concerns in Teams
+                    # Retrieve the necessary settings for Teams and Exchange Online
+                    # Condition B: Verify that 'Monitor reported messages in Microsoft Teams' is checked in the Microsoft 365 Defender portal.
+                    # Condition C: Ensure the 'Send reported messages to' setting in the Microsoft 365 Defender portal is set to 'My reporting mailbox only' with the correct report email addresses.
+                    # $ReportSubmissionPolicy Mock Object
+                    <#
+                        $ReportSubmissionPolicy = [PSCustomObject]@{
+                            ReportJunkToCustomizedAddress               = $true
+                            ReportNotJunkToCustomizedAddress            = $true
+                            ReportPhishToCustomizedAddress              = $true
+                            ReportJunkAddresses                         = @('security@example.com')
+                            ReportNotJunkAddresses                      = @('security@example.com')
+                            ReportPhishAddresses                        = @('security@example.com')
+                            ReportChatMessageEnabled                    = $false
+                            ReportChatMessageToCustomizedAddressEnabled = $false
+                        }
+                    #>
+                    $ReportSubmissionPolicy = Get-ReportSubmissionPolicy | Select-Object -Property ReportJunkToCustomizedAddress, ReportNotJunkToCustomizedAddress, ReportPhishToCustomizedAddress, ReportJunkAddresses, ReportNotJunkAddresses, ReportPhishAddresses, ReportChatMessageEnabled, ReportChatMessageToCustomizedAddressEnabled
+                    return $ReportSubmissionPolicy
+                }
+                default { throw "No match found for test: $Rec" }
+            }
+        }
+        catch {
+            throw "Get-CISExoOutput: `n$_"
+        }
+    }
+    end {
+        Write-Verbose "Retuning data for Rec: $Rec"
+    }
+} # end function Get-CISExoOutput
+

source/Private/Get-CISMSTeamsOutput.ps1

@@ -0,0 +1,338 @@
+<#
+    .SYNOPSIS
+        This is a sample Private function only visible within the module.
+    .DESCRIPTION
+        This sample function is not exported to the module and only return the data passed as parameter.
+    .EXAMPLE
+        $null = Get-CISMSTeamsOutput -PrivateData 'NOTHING TO SEE HERE'
+    .PARAMETER PrivateData
+        The PrivateData parameter is what will be returned without transformation.
+#>
+function Get-CISMSTeamsOutput {
+    [cmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [String]$Rec
+    )
+    begin {
+        # Begin Block #
+        <#
+            # Tests
+            8.1.1
+            8.1.2
+            8.2.1
+            8.5.1
+            8.5.2
+            8.5.3
+            8.5.4
+            8.5.5
+            8.5.6
+            8.5.7
+            8.6.1
+            # Test number array
+            $testNumbers = @('8.1.1', '8.1.2', '8.2.1', '8.5.1', '8.5.2', '8.5.3', '8.5.4', '8.5.5', '8.5.6', '8.5.7', '8.6.1')
+        #>
+    }
+    process {
+        try {
+            Write-Verbose "Get-CISMSTeamsOutput: Retuning data for Rec: $Rec"
+            switch ($Rec) {
+                '8.1.1' {
+                    # Test-TeamsExternalFileSharing.ps1
+                    # 8.1.1 (L2) Ensure external file sharing in Teams is enabled for only approved cloud storage services
+                    # Connect to Teams PowerShell using Connect-MicrosoftTeams
+
+                    # Condition A: The `AllowDropbox` setting is set to `False`.
+                    # Condition B: The `AllowBox` setting is set to `False`.
+                    # Condition C: The `AllowGoogleDrive` setting is set to `False`.
+                    # Condition D: The `AllowShareFile` setting is set to `False`.
+                    # Condition E: The `AllowEgnyte` setting is set to `False`.
+
+                    # Assuming that 'approvedProviders' is a list of approved cloud storage service names
+                    # This list must be defined according to your organization's approved cloud storage services
+                    # Add option for approved providers.
+                    $clientConfig = Get-CsTeamsClientConfiguration
+                    return $clientConfig
+                }
+                '8.1.2' {
+                    # Test-BlockChannelEmails.ps1
+                    # 8.1.2 (L1) Ensure users can't send emails to a channel email address
+                    #
+                    # Validate test for a pass:
+                    # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `AllowEmailIntoChannel` setting in Teams is set to `False`.
+                    #   - Condition B: The setting `Users can send emails to a channel email address` is set to `Off` in the Teams admin center.
+                    #   - Condition C: Verification using PowerShell confirms that the `AllowEmailIntoChannel` setting is disabled.
+                    #
+                    # Validate test for a fail:
+                    # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `AllowEmailIntoChannel` setting in Teams is not set to `False`.
+                    #   - Condition B: The setting `Users can send emails to a channel email address` is not set to `Off` in the Teams admin center.
+                    #   - Condition C: Verification using PowerShell indicates that the `AllowEmailIntoChannel` setting is enabled.
+
+                    # Retrieve Teams client configuration
+                    $teamsClientConfig = Get-CsTeamsClientConfiguration -Identity Global
+                    return $teamsClientConfig
+                }
+                '8.2.1' {
+                    # Test-TeamsExternalAccess.ps1
+                    # 8.2.1 (L1) Ensure 'external access' is restricted in the Teams admin center
+                    #
+                    # Validate test for a pass:
+                    # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `AllowTeamsConsumer` setting is `False`.
+                    #   - Condition B: The `AllowPublicUsers` setting is `False`.
+                    #   - Condition C: The `AllowFederatedUsers` setting is `False` or, if `True`, the `AllowedDomains` contains only authorized domain names.
+                    #
+                    # Validate test for a fail:
+                    # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `AllowTeamsConsumer` setting is not `False`.
+                    #   - Condition B: The `AllowPublicUsers` setting is not `False`.
+                    #   - Condition C: The `AllowFederatedUsers` setting is `True` and the `AllowedDomains` contains unauthorized domain names or is not configured correctly.
+                    # Connect to Teams PowerShell using Connect-MicrosoftTeams
+                    # $externalAccessConfig Mock Object
+                    <#
+                        $externalAccessConfig = [PSCustomObject]@{
+                            Identity                                    = 'Global'
+                            AllowedDomains                              = 'AllowAllKnownDomains'
+                            BlockedDomains                              = @()
+                            AllowFederatedUsers                         = $true
+                            AllowPublicUsers                            = $true
+                            AllowTeamsConsumer                          = $true
+                            AllowTeamsConsumerInbound                   = $true
+                        }
+                        $ApprovedFederatedDomains = @('msn.com', 'google.com')
+                        $externalAccessConfig = [PSCustomObject]@{
+                            Identity                                    = 'Global'
+                            AllowedDomains                              = @('msn.com', 'google.com')
+                            BlockedDomains                              = @()
+                            AllowFederatedUsers                         = $true
+                            AllowPublicUsers                            = $false
+                            AllowTeamsConsumer                          = $false
+                            AllowTeamsConsumerInbound                   = $true
+                        }
+                    #>
+                    $externalAccessConfig = Get-CsTenantFederationConfiguration
+                    return $externalAccessConfig
+                }
+                '8.5.1' {
+                    # Test-NoAnonymousMeetingJoin.ps1
+                    # 8.5.1 (L2) Ensure anonymous users can't join a meeting
+                    #
+                    # Validate test for a pass:
+                    # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+                    # - Specific conditions to check:
+                    #   - Condition A: `AllowAnonymousUsersToJoinMeeting` is set to `False`.
+                    #   - Condition B: Verification using the UI confirms that `Anonymous users can join a meeting` is set to `Off` in the Global meeting policy.
+                    #   - Condition C: PowerShell command output indicates that anonymous users are not allowed to join meetings.
+                    #
+                    # Validate test for a fail:
+                    # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+                    # - Specific conditions to check:
+                    #   - Condition A: `AllowAnonymousUsersToJoinMeeting` is not set to `False`.
+                    #   - Condition B: Verification using the UI shows that `Anonymous users can join a meeting` is not set to `Off` in the Global meeting policy.
+                    #   - Condition C: PowerShell command output indicates that anonymous users are allowed to join meetings.
+                    # Connect to Teams PowerShell using Connect-MicrosoftTeams
+                    # $teamsMeetingPolicy Mock Object
+                    <#
+                        $teamsMeetingPolicy = [PSCustomObject]@{
+                            AllowAnonymousUsersToJoinMeeting            = $true
+                        }
+                    #>
+                    $teamsMeetingPolicy = Get-CsTeamsMeetingPolicy -Identity Global
+                    return $teamsMeetingPolicy
+                }
+                '8.5.2' {
+                    # Test-NoAnonymousMeetingStart.ps1
+                    # 8.5.2 (L1) Ensure anonymous users and dial-in callers can't start a meeting
+                    #
+                    # Validate test for a pass:
+                    # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `AllowAnonymousUsersToStartMeeting` setting in the Teams admin center is set to `False`.
+                    #   - Condition B: The setting for anonymous users and dial-in callers starting a meeting is configured to ensure they must wait in the lobby.
+                    #   - Condition C: Verification using the UI confirms that the setting `Anonymous users and dial-in callers can start a meeting` is set to `Off`.
+                    #
+                    # Validate test for a fail:
+                    # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `AllowAnonymousUsersToStartMeeting` setting in the Teams admin center is not set to `False`.
+                    #   - Condition B: The setting for anonymous users and dial-in callers starting a meeting allows them to bypass the lobby.
+                    #   - Condition C: Verification using the UI indicates that the setting `Anonymous users and dial-in callers can start a meeting` is not set to `Off`.
+                    # Connect to Teams PowerShell using Connect-MicrosoftTeams
+                    # $CsTeamsMeetingPolicyAnonymous Mock Object
+                    <#
+                        $CsTeamsMeetingPolicyAnonymous = [PSCustomObject]@{
+                            AllowAnonymousUsersToStartMeeting           = $true
+                        }
+                    #>
+                    # Retrieve the Teams meeting policy for the global scope and check if anonymous users can start meetings
+                    $CsTeamsMeetingPolicyAnonymous = Get-CsTeamsMeetingPolicy -Identity Global | Select-Object -Property AllowAnonymousUsersToStartMeeting
+                    return $CsTeamsMeetingPolicyAnonymous
+                }
+                '8.5.3' {
+                    # Test-OrgOnlyBypassLobby.ps1
+                    # 8.5.3 (L1) Ensure only people in my org can bypass the lobby
+                    #
+                    # Validate test for a pass:
+                    # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `AutoAdmittedUsers` setting in the Teams meeting policy is set to `EveryoneInCompanyExcludingGuests`.
+                    #   - Condition B: The setting for "Who can bypass the lobby" is configured to "People in my org" using the UI.
+                    #   - Condition C: Verification using the Microsoft Teams admin center confirms that the meeting join & lobby settings are configured as recommended.
+                    #
+                    # Validate test for a fail:
+                    # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `AutoAdmittedUsers` setting in the Teams meeting policy is not set to `EveryoneInCompanyExcludingGuests`.
+                    #   - Condition B: The setting for "Who can bypass the lobby" is not configured to "People in my org" using the UI.
+                    #   - Condition C: Verification using the Microsoft Teams admin center indicates that the meeting join & lobby settings are not configured as recommended.
+                    # Connect to Teams PowerShell using Connect-MicrosoftTeams
+                    # Retrieve the Teams meeting policy for lobby bypass settings
+                    # $CsTeamsMeetingPolicyLobby Mock Object
+                    <#
+                        $CsTeamsMeetingPolicyLobby = [PSCustomObject]@{
+                            AutoAdmittedUsers           = "OrganizerOnly"
+                        }
+                    #>
+                    $CsTeamsMeetingPolicyLobby = Get-CsTeamsMeetingPolicy -Identity Global | Select-Object -Property AutoAdmittedUsers
+                    return $CsTeamsMeetingPolicyLobby
+                }
+                '8.5.4' {
+                    # Test-DialInBypassLobby.ps1
+                    # 8.5.4 (L1) Ensure users dialing in can't bypass the lobby
+                    #
+                    # Validate test for a pass:
+                    # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `AllowPSTNUsersToBypassLobby` setting in the Global Teams meeting policy is set to `False`.
+                    #   - Condition B: Verification using the UI in the Microsoft Teams admin center confirms that "People dialing in can't bypass the lobby" is set to `Off`.
+                    #   - Condition C: Ensure that individuals who dial in by phone must wait in the lobby until admitted by a meeting organizer, co-organizer, or presenter.
+                    #
+                    # Validate test for a fail:
+                    # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `AllowPSTNUsersToBypassLobby` setting in the Global Teams meeting policy is not set to `False`.
+                    #   - Condition B: Verification using the UI in the Microsoft Teams admin center shows that "People dialing in can't bypass the lobby" is not set to `Off`.
+                    #   - Condition C: Individuals who dial in by phone are able to join the meeting directly without waiting in the lobby.
+                    # Retrieve Teams meeting policy for PSTN users
+                    # $CsTeamsMeetingPolicyPSTN Mock Object
+                    <#
+                        $CsTeamsMeetingPolicyPSTN = [PSCustomObject]@{
+                            AllowPSTNUsersToBypassLobby           = $true
+                        }
+                    #>
+                    $CsTeamsMeetingPolicyPSTN = Get-CsTeamsMeetingPolicy -Identity Global | Select-Object -Property AllowPSTNUsersToBypassLobby
+                    return $CsTeamsMeetingPolicyPSTN
+                }
+                '8.5.5' {
+                    # Test-MeetingChatNoAnonymous.ps1
+                    # 8.5.5 (L2) Ensure meeting chat does not allow anonymous users
+                    #
+                    # Validate test for a pass:
+                    # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `MeetingChatEnabledType` setting in Teams is set to `EnabledExceptAnonymous`.
+                    #   - Condition B: The setting for meeting chat is configured to allow chat for everyone except anonymous users.
+                    #   - Condition C: Verification using the Teams Admin Center confirms that the meeting chat settings are configured as recommended.
+                    #
+                    # Validate test for a fail:
+                    # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `MeetingChatEnabledType` setting in Teams is not set to `EnabledExceptAnonymous`.
+                    #   - Condition B: The setting for meeting chat allows chat for anonymous users.
+                    #   - Condition C: Verification using the Teams Admin Center indicates that the meeting chat settings are not configured as recommended.
+                    # Retrieve the Teams meeting policy for meeting chat
+                    # $CsTeamsMeetingPolicyChat Mock Object
+                    <#
+                        $CsTeamsMeetingPolicyChat = [PSCustomObject]@{
+                            MeetingChatEnabledType           = "Enabled"
+                        }
+                    #>
+                    $CsTeamsMeetingPolicyChat = Get-CsTeamsMeetingPolicy -Identity Global | Select-Object -Property MeetingChatEnabledType
+                    return $CsTeamsMeetingPolicyChat
+                }
+                '8.5.6' {
+                    # Test-OrganizersPresent.ps1
+                    # 8.5.6 (L2) Ensure only organizers and co-organizers can present
+                    #
+                    # Validate test for a pass:
+                    # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `DesignatedPresenterRoleMode` setting in the Teams meeting policy is set to `OrganizerOnlyUserOverride`.
+                    #   - Condition B: Verification using the Teams admin center confirms that the setting "Who can present" is configured to "Only organizers and co-organizers".
+                    #   - Condition C: Verification using PowerShell confirms that the `DesignatedPresenterRoleMode` is set to `OrganizerOnlyUserOverride`.
+                    #
+                    # Validate test for a fail:
+                    # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `DesignatedPresenterRoleMode` setting in the Teams meeting policy is not set to `OrganizerOnlyUserOverride`.
+                    #   - Condition B: Verification using the Teams admin center indicates that the setting "Who can present" is not configured to "Only organizers and co-organizers".
+                    #   - Condition C: Verification using PowerShell indicates that the `DesignatedPresenterRoleMode` is not set to `OrganizerOnlyUserOverride`.
+                    # Retrieve the Teams meeting policy for presenters
+                    # $CsTeamsMeetingPolicyPresenters Mock Object
+                    <#
+                        $CsTeamsMeetingPolicyPresenters = [PSCustomObject]@{
+                            DesignatedPresenterRoleMode           = "Enabled"
+                        }
+                    #>
+                    $CsTeamsMeetingPolicyPresenters = Get-CsTeamsMeetingPolicy -Identity Global | Select-Object -Property DesignatedPresenterRoleMode
+                    return $CsTeamsMeetingPolicyPresenters
+                }
+                '8.5.7' {
+                    # Test-ExternalNoControl.ps1
+                    # 8.5.7 (L1) Ensure external participants can't give or request control
+                    #
+                    # Validate test for a pass:
+                    # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+                    # - Specific conditions to check:
+                    #   - Condition A: Ensure the `AllowExternalParticipantGiveRequestControl` setting in Teams is set to `False`.
+                    #   - Condition B: The setting is verified through the Microsoft Teams admin center or via PowerShell command.
+                    #   - Condition C: Verification using the UI confirms that external participants are unable to give or request control.
+                    #
+                    # Validate test for a fail:
+                    # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+                    # - Specific conditions to check:
+                    #   - Condition A: The `AllowExternalParticipantGiveRequestControl` setting in Teams is not set to `False`.
+                    #   - Condition B: The setting is verified through the Microsoft Teams admin center or via PowerShell command.
+                    #   - Condition C: Verification using the UI indicates that external participants can give or request control.
+                    # Retrieve Teams meeting policy for external participant control
+                    # $CsTeamsMeetingPolicyControl Mock Object
+                    <#
+                        $CsTeamsMeetingPolicyControl = [PSCustomObject]@{
+                            AllowExternalParticipantGiveRequestControl           = $true
+                        }
+                    #>
+                    $CsTeamsMeetingPolicyControl = Get-CsTeamsMeetingPolicy -Identity Global | Select-Object -Property AllowExternalParticipantGiveRequestControl
+                    return $CsTeamsMeetingPolicyControl
+                }
+                '8.6.1' {
+                    # Test-ReportSecurityInTeams.ps1
+                    # 8.6.1 (L1) Ensure users can report security concerns in Teams
+                    # Retrieve the necessary settings for Teams and Exchange Online
+                    # Condition A: Ensure the 'Report a security concern' setting in the Teams admin center is set to 'On'.
+                    # $CsTeamsMessagingPolicy Mock Object
+                    <#
+                        $CsTeamsMessagingPolicy = [PSCustomObject]@{
+                            AllowSecurityEndUserReporting           = $true
+                        }
+                    #>
+                    $CsTeamsMessagingPolicy = Get-CsTeamsMessagingPolicy -Identity Global | Select-Object -Property AllowSecurityEndUserReporting
+                    return $CsTeamsMessagingPolicy
+                }
+                default { throw "No match found for test: $Rec" }
+            }
+        }
+        catch {
+            throw "Get-CISMSTeamsOutput: `n$_"
+        }
+    }
+    end {
+        Write-Verbose "Retuning data for Rec: $Rec"
+    }
+} # end function Get-CISMSTeamsOutput
+

source/Private/Get-CISMgOutput.ps1

@@ -0,0 +1,127 @@
+function Get-CISMgOutput {
+    <#
+    .SYNOPSIS
+    This is a sample Private function only visible within the module.
+
+    .DESCRIPTION
+    This sample function is not exported to the module and only return the data passed as parameter.
+
+    .EXAMPLE
+    $null = Get-CISMgOutput -PrivateData 'NOTHING TO SEE HERE'
+
+    .PARAMETER PrivateData
+    The PrivateData parameter is what will be returned without transformation.
+
+#>
+    [cmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [String]$Rec,
+        [Parameter(Mandatory = $false)]
+        [String]$DomainName
+    )
+
+    begin {
+        # Begin Block #
+        # Tests
+        <#
+            1.1.1
+            1.1.3
+            1.2.1
+            1.3.1
+            5.1.2.3
+            5.1.8.1
+            6.1.2
+            6.1.3
+            # Test number array
+            $testNumbers = @('1.1.1', '1.1.3', '1.2.1', '1.3.1', '5.1.2.3', '5.1.8.1', '6.1.2', '6.1.3')
+        #>
+    }
+    process {
+        try {
+            Write-Verbose "Get-CISMgOutput: Retuning data for Rec: $Rec"
+            switch ($rec) {
+                '1.1.1' {
+                    # 1.1.1
+                    # Test-AdministrativeAccountCompliance
+                    $AdminRoleAssignmentsAndUsers = Get-AdminRoleUserAndAssignment
+                    return $AdminRoleAssignmentsAndUsers
+                }
+                '1.1.3' {
+                    # Test-GlobalAdminsCount
+                    # Step: Retrieve global admin role
+                    $globalAdminRole = Get-MgDirectoryRole -Filter "RoleTemplateId eq '62e90394-69f5-4237-9190-012177145e10'"
+                    # Step: Retrieve global admin members
+                    $globalAdmins = Get-MgDirectoryRoleMember -DirectoryRoleId $globalAdminRole.Id
+                    return $globalAdmins
+                }
+                '1.2.1' {
+                    # Test-ManagedApprovedPublicGroups
+                    $allGroups = Get-MgGroup -All | Where-Object { $_.Visibility -eq "Public" } | Select-Object DisplayName, Visibility
+                    return $allGroups
+                }
+                '1.2.2' {
+                    # Test-BlockSharedMailboxSignIn.ps1
+                    $users = Get-MgUser
+                    return $users
+                }
+                '1.3.1' {
+                    # Test-PasswordNeverExpirePolicy.ps1
+                    $domains = if ($DomainName) {
+                        Get-MgDomain -DomainId $DomainName
+                    }
+                    else {
+                        Get-MgDomain
+                    }
+                    return $domains
+                }
+                '5.1.2.3' {
+                    # Test-RestrictTenantCreation
+                    # Retrieve the tenant creation policy
+                    $tenantCreationPolicy = (Get-MgPolicyAuthorizationPolicy).DefaultUserRolePermissions | Select-Object AllowedToCreateTenants
+                    return $tenantCreationPolicy
+                }
+                '5.1.8.1' {
+                    # Test-PasswordHashSync
+                    # Retrieve password hash sync status (Condition A and C)
+                    $passwordHashSync = Get-MgOrganization | Select-Object -ExpandProperty OnPremisesSyncEnabled
+                    return $passwordHashSync
+                }
+                '6.1.2' {
+                    # Test-MailboxAuditingE3
+                    $tenantSKUs = Get-MgSubscribedSku -All
+                    $e3SkuPartNumber = "SPE_E3"
+                    $foundE3Sku = $tenantSKUs | Where-Object { $_.SkuPartNumber -eq $e3SkuPartNumber }
+                    if ($foundE3Sku.Count -ne 0) {
+                        $allE3Users = Get-MgUser -Filter "assignedLicenses/any(x:x/skuId eq $($foundE3Sku.SkuId) )" -All
+                        return $allE3Users
+                    }
+                    else {
+                        return $null
+                    }
+                }
+                '6.1.3' {
+                    # Test-MailboxAuditingE5
+                    $tenantSKUs = Get-MgSubscribedSku -All
+                    $e5SkuPartNumber = "SPE_E5"
+                    $foundE5Sku = $tenantSKUs | Where-Object { $_.SkuPartNumber -eq $e5SkuPartNumber }
+                    if ($foundE5Sku.Count -ne 0) {
+                        $allE5Users = Get-MgUser -Filter "assignedLicenses/any(x:x/skuId eq $($foundE5Sku.SkuId) )" -All
+                        return $allE5Users
+                    }
+                    else {
+                        return $null
+                    }
+                }
+                default { throw "No match found for test: $Rec" }
+            }
+        }
+        catch {
+            throw "Get-CISMgOutput: `n$_"
+        }
+    }
+    end {
+        Write-Verbose "Retuning data for Rec: $Rec"
+    }
+} # end function Get-CISMgOutput
+

source/Private/Get-CISSpoOutput.ps1

@@ -0,0 +1,161 @@
+<#
+    .SYNOPSIS
+        Retrieves configuration settings from SharePoint Online or PnP based on the specified recommendation.
+    .DESCRIPTION
+        The Get-CISSpoOutput function retrieves specific configuration settings from SharePoint Online or PnP based on a recommendation number.
+        It dynamically switches between using SPO and PnP commands based on the provided authentication context.
+    .PARAMETER Rec
+        The recommendation number corresponding to the specific test to be run.
+    .INPUTS
+        None. You cannot pipe objects to this function.
+    .OUTPUTS
+        PSCustomObject
+            Returns configuration details for the specified recommendation.
+    .EXAMPLE
+        PS> Get-CISSpoOutput -Rec '7.2.1'
+        Retrieves the LegacyAuthProtocolsEnabled property from the SharePoint Online or PnP tenant.
+#>
+function Get-CISSpoOutput {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true, HelpMessage = "The recommendation number corresponding to the specific test to be run.")]
+        [String]$Rec
+    )
+    begin {
+        # Check if PnP should be used
+        $UsePnP = $script:PnpAuth
+        # Determine the prefix based on the switch
+        $prefix = if ($UsePnP) { "PnP" } else { "SPO" }
+        # Define a hashtable to map the function calls
+        $commandMap = @{
+            # Test-ModernAuthSharePoint.ps1
+            # 7.2.1 (L1) Ensure Legacy Authentication Protocols are disabled
+            # $SPOTenant Mock Object
+            '7.2.1' = {
+                Invoke-Command {
+                    & "$((Get-Command -Name "Get-${prefix}Tenant").Name)"
+                } | Select-Object -Property LegacyAuthProtocolsEnabled
+            }
+            # Test-SharePointAADB2B.ps1
+            # 7.2.2 (L1) Ensure SharePoint and OneDrive integration with Azure AD B2B is enabled
+            # $SPOTenantAzureADB2B Mock Object
+            '7.2.2' = {
+                Invoke-Command {
+                    & "$((Get-Command -Name "Get-${prefix}Tenant").Name)"
+                } | Select-Object -Property EnableAzureADB2BIntegration
+            }
+            # Test-RestrictExternalSharing.ps1
+            # 7.2.3 (L1) Ensure external content sharing is restricted
+            # Retrieve the SharingCapability setting for the SharePoint tenant
+            # $SPOTenantSharingCapability Mock Object
+            '7.2.3' = {
+                Invoke-Command {
+                    & "$((Get-Command -Name "Get-${prefix}Tenant").Name)"
+                } | Select-Object -Property SharingCapability
+            }
+            # Test-OneDriveContentRestrictions.ps1
+            # 7.2.4 (L2) Ensure OneDrive content sharing is restricted
+            # $SPOTenant Mock Object
+            '7.2.4' = {
+                Invoke-Command {
+                    if ($prefix -eq "SPO") {
+                        & "$((Get-Command -Name "Get-${prefix}Tenant").Name)" | Select-Object -Property OneDriveSharingCapability
+                    } else {
+                        # Workaround until bugfix in PnP.PowerShell
+                        & "$((Get-Command -Name "Get-${prefix}Tenant").Name)" | Select-Object -Property OneDriveLoopSharingCapability | Select-Object @{Name = "OneDriveSharingCapability"; Expression = { $_.OneDriveLoopSharingCapability }}
+                    }
+                }
+            }
+            # Test-SharePointGuestsItemSharing.ps1
+            # 7.2.5 (L2) Ensure that SharePoint guest users cannot share items they don't own
+            # $SPOTenant Mock Object
+            '7.2.5' = {
+                Invoke-Command {
+                    & "$((Get-Command -Name "Get-${prefix}Tenant").Name)"
+                } | Select-Object -Property PreventExternalUsersFromResharing
+            }
+            # Test-SharePointExternalSharingDomains.ps1
+            # 7.2.6 (L2) Ensure SharePoint external sharing is managed through domain whitelist/blacklists
+            # Add Authorized Domains?
+            # $SPOTenant Mock Object
+            '7.2.6' = {
+                Invoke-Command {
+                    & "$((Get-Command -Name "Get-${prefix}Tenant").Name)"
+                } | Select-Object -Property SharingDomainRestrictionMode, SharingAllowedDomainList
+            }
+            # Test-LinkSharingRestrictions.ps1
+            # Retrieve link sharing configuration for SharePoint and OneDrive
+            # $SPOTenantLinkSharing Mock Object
+            '7.2.7' = {
+                Invoke-Command {
+                    & "$((Get-Command -Name "Get-${prefix}Tenant").Name)"
+                } | Select-Object -Property DefaultSharingLinkType
+            }
+            # Test-GuestAccessExpiration.ps1
+            # Retrieve SharePoint tenant settings related to guest access expiration
+            # $SPOTenantGuestAccess Mock Object
+            '7.2.9' = {
+                Invoke-Command {
+                    & "$((Get-Command -Name "Get-${prefix}Tenant").Name)"
+                } | Select-Object -Property ExternalUserExpirationRequired, ExternalUserExpireInDays
+            }
+            # Test-ReauthWithCode.ps1
+            # 7.2.10 (L1) Ensure reauthentication with verification code is restricted
+            # Retrieve reauthentication settings for SharePoint Online
+            # $SPOTenantReauthentication Mock Object
+            '7.2.10' = {
+                Invoke-Command {
+                    & "$((Get-Command -Name "Get-${prefix}Tenant").Name)"
+                } | Select-Object -Property EmailAttestationRequired, EmailAttestationReAuthDays
+            }
+            # Test-DisallowInfectedFilesDownload.ps1
+            # Retrieve the SharePoint tenant configuration
+            # $SPOTenantDisallowInfectedFileDownload Mock Object
+            '7.3.1' = {
+                Invoke-Command {
+                    & "$((Get-Command -Name "Get-${prefix}Tenant").Name)"
+                } | Select-Object -Property DisallowInfectedFileDownload
+            }
+            # Test-OneDriveSyncRestrictions.ps1
+            # Retrieve OneDrive sync client restriction settings
+            # Add isHybrid parameter?
+            # $SPOTenantSyncClientRestriction Mock Object
+            '7.3.2' = {
+                Invoke-Command {
+                    & "$((Get-Command -Name "Get-${prefix}TenantSyncClientRestriction").Name)"
+                } | Select-Object -Property TenantRestrictionEnabled, AllowedDomainList
+            }
+            # Test-RestrictCustomScripts.ps1
+            # Retrieve all site collections and select necessary properties
+            # $SPOSitesCustomScript Mock Object
+            '7.3.4' = {
+                Invoke-Command {
+                    if ($prefix -eq "SPO") {
+                        & "$((Get-Command -Name "Get-${prefix}Site").Name)" -Limit All | Select-Object Title, Url, DenyAddAndCustomizePages
+                    } else {
+                        & "$((Get-Command -Name "Get-${prefix}TenantSite").Name)" | Select-Object Title, Url, DenyAddAndCustomizePages
+                    }
+                }
+            }
+        }
+    }
+    process {
+        try {
+            Write-Verbose "Returning data for Rec: $Rec"
+            if ($commandMap.ContainsKey($Rec)) {
+                # Invoke the script block associated with the command
+                $result = & $commandMap[$Rec] -ErrorAction Stop
+                return $result
+            }
+            else {
+                throw "No match found for test: $Rec"
+            }
+        }
+        catch {
+            throw "Get-CISSpoOutput: `n$_"
+        }
+    }
+    end {
+        Write-Verbose "Finished processing for Rec: $Rec"
+    }
+}

source/Private/Get-ExceededLengthResultDetail.ps1

@@ -0,0 +1,54 @@
+function Get-ExceededLengthResultDetail {
+    [CmdletBinding()]
+    param (
+        [Parameter(Mandatory = $true, ParameterSetName = 'UpdateArray')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'ReturnExceedingTests')]
+        [object[]]$AuditResults,
+
+        [Parameter(Mandatory = $true, ParameterSetName = 'UpdateArray')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'ReturnExceedingTests')]
+        [string[]]$TestNumbersToCheck,
+
+        [Parameter(Mandatory = $false, ParameterSetName = 'UpdateArray')]
+        [string[]]$ExportedTests,
+
+        [Parameter(Mandatory = $true, ParameterSetName = 'ReturnExceedingTests')]
+        [switch]$ReturnExceedingTestsOnly,
+
+        [int]$DetailsLengthLimit = 30000,
+
+        [Parameter(Mandatory = $true, ParameterSetName = 'UpdateArray')]
+        [int]$PreviewLineCount = 50
+    )
+
+    $exceedingTests = @()
+    $updatedResults = @()
+
+    for ($i = 0; $i -lt $AuditResults.Count; $i++) {
+        $auditResult = $AuditResults[$i]
+        if ($auditResult.Rec -in $TestNumbersToCheck) {
+            if ($auditResult.Details.Length -gt $DetailsLengthLimit) {
+                if ($ReturnExceedingTestsOnly) {
+                    $exceedingTests += $auditResult.Rec
+                } else {
+                    $previewLines = ($auditResult.Details -split '\r?\n' | Select-Object -First $PreviewLineCount) -join "`n"
+                    $message = "The test result is too large to be exported to CSV. Use the audit result and the export function for full output.`n`nPreview:`n$previewLines"
+
+                    if ($ExportedTests -contains $auditResult.Rec) {
+                        Write-Information "The test result for $($auditResult.Rec) is too large for CSV and was included in the export. Check the exported files."
+                        $auditResult.Details = $message
+                    } else {
+                        $auditResult.Details = $message
+                    }
+                }
+            }
+        }
+        $updatedResults += $auditResult
+    }
+
+    if ($ReturnExceedingTestsOnly) {
+        return $exceedingTests
+    } else {
+        return $updatedResults
+    }
+}

source/Private/Get-MostCommonWord.ps1

@@ -0,0 +1,24 @@
+function Get-MostCommonWord {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param (
+        [Parameter(Mandatory = $true)]
+        [string[]]$InputStrings
+    )
+
+    # Combine all strings into one large string
+    $allText = $InputStrings -join ' '
+
+    # Split the large string into words
+    $words = $allText -split '\s+'
+
+    # Group words and count occurrences
+    $wordGroups = $words | Group-Object | Sort-Object Count -Descending
+
+    # Return the most common word if it occurs at least 3 times
+    if ($wordGroups.Count -gt 0 -and $wordGroups[0].Count -ge 3) {
+        return $wordGroups[0].Name
+    } else {
+        return $null
+    }
+}

source/Private/Get-PhishPolicyDetail.ps1

@@ -0,0 +1,18 @@
+function Get-PhishPolicyDetail {
+    param (
+        [Parameter(Mandatory = $true)]
+        [pscustomobject]$policy,
+
+        [Parameter(Mandatory = $true)]
+        [bool]$isCompliant
+    )
+
+    return "Policy: $($policy.Identity)`n" +
+    "Enabled: $($policy.Enabled)`n" +
+    "PhishThresholdLevel: $($policy.PhishThresholdLevel)`n" +
+    "MailboxIntelligenceProtection: $($policy.EnableMailboxIntelligenceProtection)`n" +
+    "MailboxIntelligence: $($policy.EnableMailboxIntelligence)`n" +
+    "SpoofIntelligence: $($policy.EnableSpoofIntelligence)`n" +
+    "TargetedUsersToProtect: $($policy.TargetedUsersToProtect -join ', ')`n" +
+    "IsCompliant: $isCompliant"
+}

source/Private/Get-RequiredModule.ps1

@@ -0,0 +1,38 @@
+function Get-RequiredModule {
+    [CmdletBinding(DefaultParameterSetName = 'AuditFunction')]
+    [OutputType([System.Object[]])]
+    param (
+        [Parameter(Mandatory = $true, ParameterSetName = 'AuditFunction')]
+        [switch]$AuditFunction,
+        [Parameter(Mandatory = $true, ParameterSetName = 'SyncFunction')]
+        [switch]$SyncFunction
+    )
+    switch ($PSCmdlet.ParameterSetName) {
+        'AuditFunction' {
+            if (($script:PnpAuth)) {
+                return @(
+                    @{ ModuleName = "ExchangeOnlineManagement"; RequiredVersion = "3.3.0"; SubModules = @() },
+                    @{ ModuleName = "Microsoft.Graph"; RequiredVersion = "2.4.0"; SubModules = @("DeviceManagement", "Users", "Identity.DirectoryManagement", "Identity.SignIns") },
+                    @{ ModuleName = "PnP.PowerShell"; RequiredVersion = "2.5.0"; SubModules = @() },
+                    @{ ModuleName = "MicrosoftTeams"; RequiredVersion = "5.5.0"; SubModules = @() }
+                )
+            }
+            else {
+                return @(
+                    @{ ModuleName = "ExchangeOnlineManagement"; RequiredVersion = "3.3.0"; SubModules = @() },
+                    @{ ModuleName = "Microsoft.Graph"; RequiredVersion = "2.4.0"; SubModules = @("DeviceManagement", "Users", "Identity.DirectoryManagement", "Identity.SignIns") },
+                    @{ ModuleName = "Microsoft.Online.SharePoint.PowerShell"; RequiredVersion = "16.0.24009.12000"; SubModules = @() },
+                    @{ ModuleName = "MicrosoftTeams"; RequiredVersion = "5.5.0"; SubModules = @() }
+                )
+            }
+        }
+        'SyncFunction' {
+            return @(
+                @{ ModuleName = "ImportExcel"; RequiredVersion = "7.8.9"; SubModules = @() }
+            )
+        }
+        default {
+            throw "Please specify either -AuditFunction or -SyncFunction switch."
+        }
+    }
+}

source/Private/Get-TestDefinitionsObject.ps1

@@ -0,0 +1,65 @@
+function Get-TestDefinitionsObject {
+    [CmdletBinding()]
+    [OutputType([object[]])]
+    param (
+        [Parameter(Mandatory = $true)]
+        [object[]]$TestDefinitions,
+
+        [Parameter(Mandatory = $true)]
+        [string]$ParameterSetName,
+
+        [string]$ELevel,
+        [string]$ProfileLevel,
+        [string[]]$IncludeRecommendation,
+        [string[]]$SkipRecommendation
+    )
+
+    Write-Verbose "Initial test definitions count: $($TestDefinitions.Count)"
+
+    switch ($ParameterSetName) {
+        'ELevelFilter' {
+            Write-Verbose "Applying ELevelFilter"
+            if ($null -ne $ELevel -and $null -ne $ProfileLevel) {
+                Write-Verbose "Filtering on ELevel = $ELevel and ProfileLevel = $ProfileLevel"
+                $TestDefinitions = $TestDefinitions | Where-Object {
+                    $_.ELevel -eq $ELevel -and $_.ProfileLevel -eq $ProfileLevel
+                }
+            }
+            elseif ($null -ne $ELevel) {
+                Write-Verbose "Filtering on ELevel = $ELevel"
+                $TestDefinitions = $TestDefinitions | Where-Object {
+                    $_.ELevel -eq $ELevel
+                }
+            }
+            elseif ($null -ne $ProfileLevel) {
+                Write-Verbose "Filtering on ProfileLevel = $ProfileLevel"
+                $TestDefinitions = $TestDefinitions | Where-Object {
+                    $_.ProfileLevel -eq $ProfileLevel
+                }
+            }
+        }
+        'IG1Filter' {
+            Write-Verbose "Applying IG1Filter"
+            $TestDefinitions = $TestDefinitions | Where-Object { $_.IG1 -eq 'TRUE' }
+        }
+        'IG2Filter' {
+            Write-Verbose "Applying IG2Filter"
+            $TestDefinitions = $TestDefinitions | Where-Object { $_.IG2 -eq 'TRUE' }
+        }
+        'IG3Filter' {
+            Write-Verbose "Applying IG3Filter"
+            $TestDefinitions = $TestDefinitions | Where-Object { $_.IG3 -eq 'TRUE' }
+        }
+        'RecFilter' {
+            Write-Verbose "Applying RecFilter"
+            $TestDefinitions = $TestDefinitions | Where-Object { $IncludeRecommendation -contains $_.Rec }
+        }
+        'SkipRecFilter' {
+            Write-Verbose "Applying SkipRecFilter"
+            $TestDefinitions = $TestDefinitions | Where-Object { $SkipRecommendation -notcontains $_.Rec }
+        }
+    }
+
+    Write-Verbose "Filtered test definitions count: $($TestDefinitions.Count)"
+    return $TestDefinitions
+}

source/Private/Get-TestError.ps1

@@ -0,0 +1,33 @@
+
+
+<#
+    .SYNOPSIS
+    This is a sample Private function only visible within the module.
+
+    .DESCRIPTION
+    This sample function is not exported to the module and only return the data passed as parameter.
+
+    .EXAMPLE
+    $null = Get-TestError -PrivateData 'NOTHING TO SEE HERE'
+
+    .PARAMETER PrivateData
+    The PrivateData parameter is what will be returned without transformation.
+
+#>
+
+function Get-TestError {
+    [cmdletBinding()]
+    param (
+        $LastError,
+        $recnum
+    )
+    # Retrieve the description from the test definitions
+    $testDefinition = $script:TestDefinitionsObject | Where-Object { $_.Rec -eq $recnum }
+    $description = if ($testDefinition) { $testDefinition.RecDescription } else { "Description not found" }
+    $script:FailedTests.Add([PSCustomObject]@{ Rec = $recnum; Description = $description; Error = $LastError })
+    # Call Initialize-CISAuditResult with error parameters
+    $auditResult = Initialize-CISAuditResult -Rec $recnum -Failure
+    Write-Verbose "An error occurred during the test $recnum`: `n$LastError" -Verbose
+    return $auditResult
+}
+

source/Private/Get-UniqueConnection.ps1

@@ -0,0 +1,25 @@
+function Get-UniqueConnection {
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param (
+        [Parameter(Mandatory = $true)]
+        [string[]]$Connections
+    )
+
+    $uniqueConnections = @()
+
+    if ($Connections -contains "Microsoft Graph" -or $Connections -contains "AzureAD | EXO | Microsoft Graph" -or $Connections -contains "EXO | Microsoft Graph") {
+        $uniqueConnections += "Microsoft Graph"
+    }
+    if ($Connections -contains "EXO" -or $Connections -contains "AzureAD | EXO" -or $Connections -contains "Microsoft Teams | EXO" -or $Connections -contains "AzureAD | EXO | Microsoft Graph") {
+        $uniqueConnections += "EXO"
+    }
+    if ($Connections -contains "SPO") {
+        $uniqueConnections += "SPO"
+    }
+    if ($Connections -contains "Microsoft Teams" -or $Connections -contains "Microsoft Teams | EXO") {
+        $uniqueConnections += "Microsoft Teams"
+    }
+
+    return $uniqueConnections | Sort-Object -Unique
+}

source/Private/Get-UrlLine.ps1

@@ -0,0 +1,32 @@
+<#
+    .SYNOPSIS
+        This is a sample Private function only visible within the module.
+
+    .DESCRIPTION
+        This sample function is not exported to the module and only return the data passed as parameter.
+
+    .EXAMPLE
+        $null = Get-UrlLine -PrivateData 'NOTHING TO SEE HERE'
+
+    .PARAMETER PrivateData
+        The PrivateData parameter is what will be returned without transformation.
+#>
+function Get-UrlLine {
+    [cmdletBinding()]
+    [OutputType([string])]
+        param (
+            [Parameter(Mandatory=$true)]
+            [string]$Output
+        )
+        # Split the output into lines
+        $Lines = $Output -split "`n"
+        # Iterate over each line
+        foreach ($Line in $Lines) {
+            # If the line starts with 'https', return it
+            if ($Line.StartsWith('https')) {
+                return $Line.Trim()
+            }
+        }
+        # If no line starts with 'https', return an empty string
+        return $null
+    }

source/Private/Initialize-CISAuditResult.ps1

@@ -0,0 +1,62 @@
+function Initialize-CISAuditResult {
+    [CmdletBinding()]
+    [OutputType([CISAuditResult])]
+    param (
+        [Parameter(Mandatory = $true)]
+        [string]$Rec,
+
+        [Parameter(Mandatory = $true, ParameterSetName = 'Full')]
+        [bool]$Result,
+
+        [Parameter(Mandatory = $true, ParameterSetName = 'Full')]
+        [string]$Status,
+
+        [Parameter(Mandatory = $true, ParameterSetName = 'Full')]
+        [string]$Details,
+
+        [Parameter(Mandatory = $true, ParameterSetName = 'Full')]
+        [string]$FailureReason,
+
+        [Parameter(ParameterSetName = 'Error')]
+        [switch]$Failure
+    )
+
+    # Import the test definitions CSV file
+    $testDefinitions = $script:TestDefinitionsObject
+
+    # Find the row that matches the provided recommendation (Rec)
+    $testDefinition = $testDefinitions | Where-Object { $_.Rec -eq $Rec }
+
+    if (-not $testDefinition) {
+        throw "Test definition for recommendation '$Rec' not found."
+    }
+
+    # Create an instance of CISAuditResult and populate it
+    $auditResult = [CISAuditResult]::new()
+    $auditResult.Rec = $Rec
+    $auditResult.ELevel = $testDefinition.ELevel
+    $auditResult.ProfileLevel = $testDefinition.ProfileLevel
+    $auditResult.IG1 = [bool]::Parse($testDefinition.IG1)
+    $auditResult.IG2 = [bool]::Parse($testDefinition.IG2)
+    $auditResult.IG3 = [bool]::Parse($testDefinition.IG3)
+    $auditResult.RecDescription = $testDefinition.RecDescription
+    $auditResult.CISControl = $testDefinition.CISControl
+    $auditResult.CISDescription = $testDefinition.CISDescription
+    $auditResult.Automated = [bool]::Parse($testDefinition.Automated)
+    $auditResult.Connection = $testDefinition.Connection
+    $auditResult.CISControlVer = 'v8'
+
+    if ($PSCmdlet.ParameterSetName -eq 'Full') {
+        $auditResult.Result = $Result
+        $auditResult.Status = $Status
+        $auditResult.Details = $Details
+        $auditResult.FailureReason = $FailureReason
+    } elseif ($PSCmdlet.ParameterSetName -eq 'Error') {
+        $auditResult.Result = $false
+        $auditResult.Status = 'Fail'
+        $auditResult.Details = "An error occurred while processing the test."
+        $auditResult.FailureReason = "Initialization error: Failed to process the test."
+    }
+
+    return $auditResult
+}

source/Private/Initialize-LargeTestTable.ps1

@@ -0,0 +1,36 @@
+<#
+    .SYNOPSIS
+    This function generates a large table with the specified number of lines.
+    .DESCRIPTION
+    This function generates a large table with the specified number of lines. The table has a header and each line has the same format.
+    .EXAMPLE
+    Initialize-LargeTestTable -lineCount 1000
+    .PARAMETER lineCount
+    The number of lines to generate.
+    .INPUTS
+    System.Int32
+    .OUTPUTS
+    System.String
+    .NOTES
+    The function is intended for testing purposes.
+#>
+function Initialize-LargeTestTable {
+    [cmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter()]
+        [int]$lineCount = 1000 # Number of lines to generate
+    )
+    process {
+        $header = "UserPrincipalName|AuditEnabled|AdminActionsMissing|DelegateActionsMissing|OwnerActionsMissing"
+        $lineTemplate = "user{0}@contosonorthwind.net|True|FB,CP,MV|FB,MV|ML,MV,CR"
+        # Generate the header and lines
+        $lines = @($header)
+        for ($i = 1; $i -le $lineCount; $i++) {
+            $lines += [string]::Format($lineTemplate, $i)
+        }
+        $output = $lines -join "`n"
+        Write-Host "Details character count: $($output.Length)"
+        return $output
+    }
+}

source/Private/Invoke-TestFunction.ps1

@@ -0,0 +1,43 @@
+function Invoke-TestFunction {
+    [OutputType([CISAuditResult[]])]
+    param (
+        [Parameter(Mandatory = $true)]
+        [PSObject]$FunctionFile,
+        [Parameter(Mandatory = $false)]
+        [string]$DomainName,
+        [Parameter(Mandatory = $false)]
+        [string[]]$ApprovedCloudStorageProviders,
+        [Parameter(Mandatory = $false)]
+        [string[]]$ApprovedFederatedDomains
+    )
+
+    $functionName = $FunctionFile.BaseName
+    $functionCmd = Get-Command -Name $functionName
+
+    # Check if the test function needs DomainName parameter
+    $paramList = @{}
+    if ('DomainName' -in $functionCmd.Parameters.Keys) {
+        $paramList.DomainName = $DomainName
+    }
+    if ('ApprovedCloudStorageProviders' -in $functionCmd.Parameters.Keys) {
+        $paramList.ApprovedCloudStorageProviders = $ApprovedCloudStorageProviders
+    }
+    if ('ApprovedFederatedDomains' -in $functionCmd.Parameters.Keys) {
+        $paramList.ApprovedFederatedDomains = $ApprovedFederatedDomains
+    }
+    # Use splatting to pass parameters
+    Write-Verbose "Running $functionName..."
+    try {
+        $result = & $functionName @paramList
+        # Assuming each function returns an array of CISAuditResult or a single CISAuditResult
+        return $result
+    }
+    catch {
+        Write-Error "An error occurred during the test $recnum`:: $_"
+        $script:FailedTests.Add([PSCustomObject]@{ Test = $functionName; Error = $_ })
+
+        # Call Initialize-CISAuditResult with error parameters
+        $auditResult = Initialize-CISAuditResult -Rec $functionName -Failure
+        return $auditResult
+    }
+}

source/Private/Measure-AuditResult.ps1

@@ -0,0 +1,32 @@
+function Measure-AuditResult {
+    [OutputType([void])]
+    param (
+        [Parameter(Mandatory = $true)]
+        [System.Collections.ArrayList]$AllAuditResults,
+
+        [Parameter(Mandatory = $false)]
+        [System.Collections.ArrayList]$FailedTests
+    )
+
+    # Calculate the total number of tests
+    $totalTests = $AllAuditResults.Count
+
+    # Calculate the number of passed tests
+    $passedTests = $AllAuditResults.ToArray() | Where-Object { $_.Result -eq $true } | Measure-Object | Select-Object -ExpandProperty Count
+
+    # Calculate the pass percentage
+    $passPercentage = if ($totalTests -eq 0) { 0 } else { [math]::Round(($passedTests / $totalTests) * 100, 2) }
+
+    # Display the pass percentage to the user
+    Write-Information "Audit completed. $passedTests out of $totalTests tests passed."
+    Write-Information "Your passing percentage is $passPercentage%."
+
+    # Display details of failed tests
+    if ($FailedTests.Count -gt 0) {
+        Write-Verbose "The following tests failed to complete:"
+        foreach ($failedTest in $FailedTests) {
+            Write-Verbose "Test: $($failedTest.Test)"
+            Write-Verbose "Error: $($failedTest.Error)"
+        }
+    }
+}

source/Private/Test-IsAdmin.ps1

@@ -0,0 +1,22 @@
+function Test-IsAdmin {
+    <#
+    .SYNOPSIS
+    Checks if the current user is an administrator on the machine.
+    .DESCRIPTION
+    This private function returns a Boolean value indicating whether
+    the current user has administrator privileges on the machine.
+    It does this by creating a new WindowsPrincipal object, passing
+    in a WindowsIdentity object representing the current user, and
+    then checking if that principal is in the Administrator role.
+    .INPUTS
+    None.
+    .OUTPUTS
+    Boolean. Returns True if the current user is an administrator, and False otherwise.
+    .EXAMPLE
+    PS C:\> Test-IsAdmin
+    True
+    #>
+
+    # Create a new WindowsPrincipal object for the current user and check if it is in the Administrator role
+    (New-Object Security.Principal.WindowsPrincipal ([Security.Principal.WindowsIdentity]::GetCurrent())).IsInRole([Security.Principal.WindowsBuiltinRole]::Administrator)
+}

source/Private/Test-PhishPolicyCompliance.ps1

@@ -0,0 +1,8 @@
+function Test-PhishPolicyCompliance {
+    param ($policy)
+    return ($policy.Enabled -eq $true -and
+        $policy.PhishThresholdLevel -ge 2 -and
+        $policy.EnableMailboxIntelligenceProtection -eq $true -and
+        $policy.EnableMailboxIntelligence -eq $true -and
+        $policy.EnableSpoofIntelligence -eq $true)
+}

source/Private/Write-AuditLog.ps1

@@ -0,0 +1,212 @@
+function Write-AuditLog {
+    <#
+    .SYNOPSIS
+        Writes log messages to the console and updates the script-wide log variable.
+    .DESCRIPTION
+        The Write-AuditLog function writes log messages to the console based on the severity (Verbose, Warning, or Error) and updates
+        the script-wide log variable ($script:LogString) with the log entry. You can use the Start, End, and EndFunction switches to
+        manage the lifecycle of the logging.
+    .INPUTS
+        System.String
+        You can pipe a string to the Write-AuditLog function as the Message parameter.
+        You can also pipe an object with a Severity property as the Severity parameter.
+    .OUTPUTS
+        None
+        The Write-AuditLog function doesn't output any objects to the pipeline. It writes messages to the console and updates the
+        script-wide log variable ($script:LogString).
+    .PARAMETER BeginFunction
+        Sets the message to "Begin [FunctionName] function log.", where FunctionName is the name of the calling function, and adds it to the log variable.
+    .PARAMETER Message
+        The message string to log.
+    .PARAMETER Severity
+        The severity of the log message. Accepted values are 'Information', 'Warning', and 'Error'. Defaults to 'Information'.
+    .PARAMETER Start
+        Initializes the script-wide log variable and sets the message to "Begin [FunctionName] Log.", where FunctionName is the name of the calling function.
+    .PARAMETER End
+        Sets the message to "End Log" and exports the log to a CSV file if the OutputPath parameter is provided.
+    .PARAMETER EndFunction
+        Sets the message to "End [FunctionName] log.", where FunctionName is the name of the calling function, and adds it to the log variable.
+    .PARAMETER OutputPath
+        The file path for exporting the log to a CSV file when using the End switch.
+    .EXAMPLE
+        Write-AuditLog -Message "This is a test message."
+
+        Writes a test message with the default severity (Information) to the console and adds it to the log variable.
+    .EXAMPLE
+        Write-AuditLog -Message "This is a warning message." -Severity "Warning"
+
+        Writes a warning message to the console and adds it to the log variable.
+    .EXAMPLE
+        Write-AuditLog -Start
+
+        Initializes the log variable and sets the message to "Begin [FunctionName] Log.", where FunctionName is the name of the calling function.
+    .EXAMPLE
+        Write-AuditLog -BeginFunction
+
+        Sets the message to "Begin [FunctionName] function log.", where FunctionName is the name of the calling function, and adds it to the log variable.
+    .EXAMPLE
+        Write-AuditLog -EndFunction
+
+        Sets the message to "End [FunctionName] log.", where FunctionName is the name of the calling function, and adds it to the log variable.
+    .EXAMPLE
+        Write-AuditLog -End -OutputPath "C:\Logs\auditlog.csv"
+
+        Sets the message to "End Log", adds it to the log variable, and exports the log to a CSV file.
+    .NOTES
+    Author: DrIOSx
+#>
+    [CmdletBinding(DefaultParameterSetName = 'Default')]
+    param(
+        ###
+        [Parameter(
+            Mandatory = $false,
+            HelpMessage = 'Input a Message string.',
+            Position = 0,
+            ParameterSetName = 'Default',
+            ValueFromPipeline = $true
+        )]
+        [ValidateNotNullOrEmpty()]
+        [string]$Message,
+        ###
+        [Parameter(
+            Mandatory = $false,
+            HelpMessage = 'Information, Warning or Error.',
+            Position = 1,
+            ParameterSetName = 'Default',
+            ValueFromPipelineByPropertyName = $true
+        )]
+        [ValidateNotNullOrEmpty()]
+        [ValidateSet('Information', 'Warning', 'Error')]
+        [string]$Severity = 'Information',
+        ###
+        [Parameter(
+            Mandatory = $false,
+            ParameterSetName = 'End'
+        )]
+        [switch]$End,
+        ###
+        [Parameter(
+            Mandatory = $false,
+            ParameterSetName = 'BeginFunction'
+        )]
+        [switch]$BeginFunction,
+        [Parameter(
+            Mandatory = $false,
+            ParameterSetName = 'EndFunction'
+        )]
+        [switch]$EndFunction,
+        ###
+        [Parameter(
+            Mandatory = $false,
+            ParameterSetName = 'Start'
+        )]
+        [switch]$Start,
+        ###
+        [Parameter(
+            Mandatory = $false,
+            ParameterSetName = 'End'
+        )]
+        [string]$OutputPath
+    )
+    begin {
+        $ErrorActionPreference = "SilentlyContinue"
+        # Define variables to hold information about the command that was invoked.
+        $ModuleName = $Script:MyInvocation.MyCommand.Name -replace '\..*'
+        $callStack = Get-PSCallStack
+        if ($callStack.Count -gt 1) {
+            $FuncName = $callStack[1].Command
+        } else {
+            $FuncName = "DirectCall"  # Or any other default name you prefer
+        }
+        #Write-Verbose "Funcname Name is $FuncName!" -Verbose
+        $ModuleVer = $MyInvocation.MyCommand.Version.ToString()
+        # Set the error action preference to continue.
+        $ErrorActionPreference = "Continue"
+    }
+    process {
+        try {
+            if (-not $Start -and -not (Test-Path variable:script:LogString)) {
+                throw "The logging variable is not initialized. Please call Write-AuditLog with the -Start switch or ensure $script:LogString is set."
+            }
+            $Function = $($FuncName + '.v' + $ModuleVer)
+            if ($Start) {
+                $script:LogString = @()
+                $Message = '+++ Begin Log | ' + $Function + ' |'
+            }
+            elseif ($BeginFunction) {
+                $Message = '>>> Begin Function Log | ' + $Function + ' |'
+            }
+            $logEntry = [pscustomobject]@{
+                Time      = ((Get-Date).ToString('yyyy-MM-dd hh:mmTss'))
+                Module    = $ModuleName
+                PSVersion = ($PSVersionTable.PSVersion).ToString()
+                PSEdition = ($PSVersionTable.PSEdition).ToString()
+                IsAdmin   = $(Test-IsAdmin)
+                User      = "$Env:USERDOMAIN\$Env:USERNAME"
+                HostName  = $Env:COMPUTERNAME
+                InvokedBy = $Function
+                Severity  = $Severity
+                Message   = $Message
+                RunID     = -1
+            }
+            if ($BeginFunction) {
+                $maxRunID = ($script:LogString | Where-Object { $_.InvokedBy -eq $Function } | Measure-Object -Property RunID -Maximum).Maximum
+                if ($null -eq $maxRunID) { $maxRunID = -1 }
+                $logEntry.RunID = $maxRunID + 1
+            }
+            else {
+                $lastRunID = ($script:LogString | Where-Object { $_.InvokedBy -eq $Function } | Select-Object -Last 1).RunID
+                if ($null -eq $lastRunID) { $lastRunID = 0 }
+                $logEntry.RunID = $lastRunID
+            }
+            if ($EndFunction) {
+                $FunctionStart = "$((($script:LogString | Where-Object {$_.InvokedBy -eq $Function -and $_.RunId -eq $lastRunID } | Sort-Object Time)[0]).Time)"
+                $startTime = ([DateTime]::ParseExact("$FunctionStart", 'yyyy-MM-dd hh:mmTss', $null))
+                $endTime = Get-Date
+                $timeTaken = $endTime - $startTime
+                $Message = '<<< End Function Log   | ' + $Function + ' | Runtime: ' + "$($timeTaken.Minutes) min $($timeTaken.Seconds) sec"
+                $logEntry.Message = $Message
+            }
+            elseif ($End) {
+                $startTime = ([DateTime]::ParseExact($($script:LogString[0].Time), 'yyyy-MM-dd hh:mmTss', $null))
+                $endTime = Get-Date
+                $timeTaken = $endTime - $startTime
+                $Message = '--- End Log   | ' + $Function + ' | Runtime: ' + "$($timeTaken.Minutes) min $($timeTaken.Seconds) sec"
+                $logEntry.Message = $Message
+            }
+            $script:LogString += $logEntry
+            switch ($Severity) {
+                'Warning' {
+                    Write-Warning ('[WARNING] ! ' + $Message)
+                    $UserInput = Read-Host "Warning encountered! Do you want to continue? (Y/N)"
+                    if ($UserInput -eq 'N') {
+                        throw "Script execution stopped by user."
+                    }
+                }
+                'Error'       { Write-Error ('[ERROR] X - ' + $FuncName + ' ' + $Message) -ErrorAction Continue }
+                'Verbose'     { Write-Verbose ('[VERBOSE] ~ ' + $Message) }
+                Default { Write-Information ('[INFO] * ' + $Message)  -InformationAction Continue}
+            }
+        }
+        catch {
+            throw "Write-AuditLog encountered an error (process block): $($_)"
+        }
+
+    }
+    end {
+        try {
+            if ($End) {
+                if (-not [string]::IsNullOrEmpty($OutputPath)) {
+                    $script:LogString | Export-Csv -Path $OutputPath -NoTypeInformation
+                    Write-Verbose "LogPath: $(Split-Path -Path $OutputPath -Parent)"
+                }
+                else {
+                    throw "OutputPath is not specified for End action."
+                }
+            }
+        }
+        catch {
+            throw "Error in Write-AuditLog (end block): $($_.Exception.Message)"
+        }
+    }
+}

source/Public/Export-M365SecurityAuditTable.ps1

@@ -0,0 +1,235 @@
+<#
+    .SYNOPSIS
+        Exports Microsoft 365 security audit results to CSV or Excel files and supports outputting specific test results as objects.
+    .DESCRIPTION
+        The Export-M365SecurityAuditTable function exports Microsoft 365 security audit results from an array of CISAuditResult objects or a CSV file.
+        It can export all results to a specified path, output a specific test result as an object, and includes options for exporting results to Excel.
+        Additionally, it computes hashes for the exported files and includes them in the zip archive for verification purposes.
+    .PARAMETER AuditResults
+        An array of CISAuditResult objects containing the audit results. This parameter is mandatory when exporting from audit results.
+    .PARAMETER CsvPath
+        The path to a CSV file containing the audit results. This parameter is mandatory when exporting from a CSV file.
+    .PARAMETER OutputTestNumber
+        The test number to output as an object. Valid values are "1.1.1", "1.3.1", "6.1.2", "6.1.3", "7.3.4". This parameter is used to output a specific test result.
+    .PARAMETER ExportNestedTables
+        Switch to export all test results. When specified, all test results are exported to the specified path.
+    .PARAMETER ExportPath
+        The path where the CSV or Excel files will be exported. This parameter is mandatory when exporting all tests.
+    .PARAMETER ExportOriginalTests
+        Switch to export the original audit results to a CSV file. When specified, the original test results are exported along with the processed results.
+    .PARAMETER ExportToExcel
+        Switch to export the results to an Excel file. When specified, results are exported in Excel format.
+    .INPUTS
+        [CISAuditResult[]] - An array of CISAuditResult objects.
+            [string] - A path to a CSV file.
+    .OUTPUTS
+        [PSCustomObject] - A custom object containing the path to the zip file and its hash.
+    .EXAMPLE
+        Export-M365SecurityAuditTable -AuditResults $object -OutputTestNumber 6.1.2
+            # Outputs the result of test number 6.1.2 from the provided audit results as an object.
+    .EXAMPLE
+        Export-M365SecurityAuditTable -ExportNestedTables -AuditResults $object -ExportPath "C:\temp"
+            # Exports all audit results to the specified path in CSV format.
+    .EXAMPLE
+        Export-M365SecurityAuditTable -CsvPath "C:\temp\auditresultstoday1.csv" -OutputTestNumber 6.1.2
+            # Outputs the result of test number 6.1.2 from the CSV file as an object.
+    .EXAMPLE
+        Export-M365SecurityAuditTable -ExportNestedTables -CsvPath "C:\temp\auditresultstoday1.csv" -ExportPath "C:\temp"
+            # Exports all audit results from the CSV file to the specified path in CSV format.
+    .EXAMPLE
+        Export-M365SecurityAuditTable -ExportNestedTables -AuditResults $object -ExportPath "C:\temp" -ExportOriginalTests
+            # Exports all audit results along with the original test results to the specified path in CSV format.
+    .EXAMPLE
+        Export-M365SecurityAuditTable -ExportNestedTables -CsvPath "C:\temp\auditresultstoday1.csv" -ExportPath "C:\temp" -ExportOriginalTests
+            # Exports all audit results from the CSV file along with the original test results to the specified path in CSV format.
+    .EXAMPLE
+        Export-M365SecurityAuditTable -ExportNestedTables -AuditResults $object -ExportPath "C:\temp" -ExportToExcel
+            # Exports all audit results to the specified path in Excel format.
+    .LINK
+        https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Export-M365SecurityAuditTable
+#>
+function Export-M365SecurityAuditTable {
+    [CmdletBinding(SupportsShouldProcess, ConfirmImpact = 'High')]
+    [OutputType([PSCustomObject])]
+    param (
+        [Parameter(Mandatory = $true, Position = 1, ParameterSetName = "ExportAllResultsFromAuditResults")]
+        [Parameter(Mandatory = $true, Position = 2, ParameterSetName = "OutputObjectFromAuditResultsSingle")]
+        [CISAuditResult[]]$AuditResults,
+        [Parameter(Mandatory = $true, Position = 1, ParameterSetName = "ExportAllResultsFromCsv")]
+        [Parameter(Mandatory = $true, Position = 2, ParameterSetName = "OutputObjectFromCsvSingle")]
+        [ValidateScript({ (Test-Path $_) -and ((Get-Item $_).PSIsContainer -eq $false) })]
+        [string]$CsvPath,
+        [Parameter(Mandatory = $true, Position = 1, ParameterSetName = "OutputObjectFromAuditResultsSingle")]
+        [Parameter(Mandatory = $true, Position = 1, ParameterSetName = "OutputObjectFromCsvSingle")]
+        [ValidateSet("1.1.1", "1.3.1", "6.1.2", "6.1.3", "7.3.4")]
+        [string]$OutputTestNumber,
+        [Parameter(Mandatory = $false, Position = 0, ParameterSetName = "ExportAllResultsFromAuditResults")]
+        [Parameter(Mandatory = $false, Position = 0, ParameterSetName = "ExportAllResultsFromCsv")]
+        [switch]$ExportNestedTables,
+        [Parameter(Mandatory = $true, ParameterSetName = "ExportAllResultsFromAuditResults")]
+        [Parameter(Mandatory = $true, ParameterSetName = "ExportAllResultsFromCsv")]
+        [string]$ExportPath,
+        [Parameter(Mandatory = $false, ParameterSetName = "ExportAllResultsFromAuditResults")]
+        [Parameter(Mandatory = $false, ParameterSetName = "ExportAllResultsFromCsv")]
+        [switch]$ExportOriginalTests,
+        [Parameter(Mandatory = $false, ParameterSetName = "ExportAllResultsFromAuditResults")]
+        [Parameter(Mandatory = $false, ParameterSetName = "ExportAllResultsFromCsv")]
+        [switch]$ExportToExcel,
+        # Add Prefix to filename after date when outputting to excel or csv.
+        [Parameter(Mandatory = $false, ParameterSetName = "ExportAllResultsFromAuditResults")]
+        [Parameter(Mandatory = $false, ParameterSetName = "ExportAllResultsFromCsv")]
+        # Validate that the count of letters in the prefix is less than 5.
+        [ValidateLength(0, 5)]
+        [string]$Prefix = "Corp"
+    )
+    Begin {
+        $createdFiles = @() # Initialize an array to keep track of created files
+
+        if ($ExportToExcel) {
+            if ($PSCmdlet.ShouldProcess("ImportExcel v7.8.9", "Assert-ModuleAvailability")) {
+                Assert-ModuleAvailability -ModuleName ImportExcel -RequiredVersion "7.8.9"
+            }
+        }
+        if ($PSCmdlet.ParameterSetName -like "ExportAllResultsFromCsv" -or $PSCmdlet.ParameterSetName -eq "OutputObjectFromCsvSingle") {
+            $AuditResults = Import-Csv -Path $CsvPath | ForEach-Object {
+                $params = @{
+                    Rec           = $_.Rec
+                    Result        = [bool]$_.Result
+                    Status        = $_.Status
+                    Details       = $_.Details
+                    FailureReason = $_.FailureReason
+                }
+                Initialize-CISAuditResult @params
+            }
+        }
+        if ($ExportNestedTables) {
+            $TestNumbers = "1.1.1", "1.3.1", "6.1.2", "6.1.3", "7.3.4"
+        }
+        $results = @()
+        $testsToProcess = if ($OutputTestNumber) { @($OutputTestNumber) } else { $TestNumbers }
+    }
+    Process {
+        foreach ($test in $testsToProcess) {
+            $auditResult = $AuditResults | Where-Object { $_.Rec -eq $test }
+            if (-not $auditResult) {
+                Write-Information "No audit results found for the test number $test."
+                continue
+            }
+            switch ($test) {
+                "6.1.2" {
+                    $details = $auditResult.Details
+                    $newObjectDetails = Get-AuditMailboxDetail -Details $details -Version '6.1.2'
+                    $results += [PSCustomObject]@{ TestNumber = $test; Details = $newObjectDetails }
+                }
+                "6.1.3" {
+                    $details = $auditResult.Details
+                    $newObjectDetails = Get-AuditMailboxDetail -Details $details -Version '6.1.3'
+                    $results += [PSCustomObject]@{ TestNumber = $test; Details = $newObjectDetails }
+                }
+                Default {
+                    $details = $auditResult.Details
+                    $csv = $details | ConvertFrom-Csv -Delimiter '|'
+                    $results += [PSCustomObject]@{ TestNumber = $test; Details = $csv }
+                }
+            }
+        }
+    }
+    End {
+        if ($ExportPath) {
+            if ($PSCmdlet.ShouldProcess("Export-M365SecurityAuditTable", "Exporting results to $ExportPath")) {
+                $timestamp = (Get-Date).ToString("yyyy.MM.dd_HH.mm.ss")
+                $exportedTests = @()
+                foreach ($result in $results) {
+                    $testDef = $script:TestDefinitionsObject | Where-Object { $_.Rec -eq $result.TestNumber }
+                    if ($testDef) {
+                        $fileName = "$ExportPath\$($timestamp)_$($result.TestNumber).$($testDef.TestFileName -replace '\.ps1$').csv"
+                        if ($result.Details.Count -eq 0) {
+                            Write-Information "No results found for test number $($result.TestNumber)."
+                        }
+                        else {
+                            if (($result.Details -ne "No M365 E3 licenses found.") -and ($result.Details -ne "No M365 E5 licenses found.")) {
+                                if ($ExportToExcel) {
+                                    $xlsxPath = [System.IO.Path]::ChangeExtension($fileName, '.xlsx')
+                                    $result.Details | Export-Excel -Path $xlsxPath -WorksheetName Table -TableName Table -AutoSize -TableStyle Medium2
+                                    $createdFiles += $xlsxPath # Add the created file to the array
+                                }
+                                else {
+                                    $result.Details | Export-Csv -Path $fileName -NoTypeInformation
+                                    $createdFiles += $fileName # Add the created file to the array
+                                }
+                                $exportedTests += $result.TestNumber
+                            }
+                        }
+                    }
+                }
+                if ($exportedTests.Count -gt 0) {
+                    Write-Information "The following tests were exported: $($exportedTests -join ', ')"
+                }
+                else {
+                    if ($ExportOriginalTests) {
+                        Write-Information "Full audit results exported however, none of the following tests had exports: `n1.1.1, 1.3.1, 6.1.2, 6.1.3, 7.3.4"
+                    }
+                    else {
+                        Write-Information "No specified tests were included in the export."
+                    }
+                }
+                if ($ExportOriginalTests) {
+                    # Define the test numbers to check
+                    $TestNumbersToCheck = "1.1.1", "1.3.1", "6.1.2", "6.1.3", "7.3.4"
+                    # Check for large details and update the AuditResults array
+                    $updatedAuditResults = Get-ExceededLengthResultDetail -AuditResults $AuditResults -TestNumbersToCheck $TestNumbersToCheck -ExportedTests $exportedTests -DetailsLengthLimit 30000 -PreviewLineCount 25
+                    $originalFileName = "$ExportPath\$timestamp`_$Prefix-M365FoundationsAudit.csv"
+                    if ($ExportToExcel) {
+                        $xlsxPath = [System.IO.Path]::ChangeExtension($originalFileName, '.xlsx')
+                        $updatedAuditResults | Export-Excel -Path $xlsxPath -WorksheetName Table -TableName Table -AutoSize -TableStyle Medium2
+                        $createdFiles += $xlsxPath # Add the created file to the array
+                    }
+                    else {
+                        $updatedAuditResults | Export-Csv -Path $originalFileName -NoTypeInformation
+                        $createdFiles += $originalFileName # Add the created file to the array
+                    }
+                }
+                # Hash each file and add it to a dictionary
+                # Hash each file and save the hashes to a text file
+                $hashFilePath = "$ExportPath\$timestamp`_Hashes.txt"
+                $fileHashes = @()
+                foreach ($file in $createdFiles) {
+                    $hash = Get-FileHash -Path $file -Algorithm SHA256
+                    $fileHashes += "$($file): $($hash.Hash)"
+                }
+                $fileHashes | Set-Content -Path $hashFilePath
+                $createdFiles += $hashFilePath # Add the hash file to the array
+                # Create a zip file and add all the created files
+                $zipFilePath = "$ExportPath\$timestamp`_$Prefix-M365FoundationsAudit.zip"
+                Compress-Archive -Path $createdFiles -DestinationPath $zipFilePath
+                # Remove the original files after they have been added to the zip
+                foreach ($file in $createdFiles) {
+                    Remove-Item -Path $file -Force
+                }
+                # Compute the hash for the zip file and rename it
+                $zipHash = Get-FileHash -Path $zipFilePath -Algorithm SHA256
+                $newZipFilePath = "$ExportPath\$timestamp`_$Prefix-M365FoundationsAudit_$($zipHash.Hash.Substring(0, 8)).zip"
+                Rename-Item -Path $zipFilePath -NewName $newZipFilePath
+                # Output the zip file path with hash
+                return [PSCustomObject]@{
+                    ZipFilePath = $newZipFilePath
+                }
+            }
+        } # End of ExportPath
+        elseif ($OutputTestNumber) {
+            if ($results[0].Details) {
+                return $results[0].Details
+            }
+            else {
+                Write-Information "No results found for test number $($OutputTestNumber)."
+            }
+        }
+        else {
+            Write-Error "No valid operation specified. Please provide valid parameters."
+        }
+        # Output the created files at the end
+        #if ($createdFiles.Count -gt 0) {
+        ###########    $createdFiles
+        #}
+    }
+}

source/Public/Get-AdminRoleUserLicense.ps1

@@ -0,0 +1,91 @@
+<#
+.SYNOPSIS
+    Retrieves user licenses and roles for administrative accounts from Microsoft 365 via the Graph API.
+.DESCRIPTION
+    The Get-AdminRoleUserLicense function connects to Microsoft Graph and retrieves all users who are assigned administrative roles along with their user details and licenses. This function is useful for auditing and compliance checks to ensure that administrators have appropriate licenses and role assignments.
+.PARAMETER SkipGraphConnection
+    A switch parameter that, when set, skips the connection to Microsoft Graph if already established. This is useful for batch processing or when used within scripts where multiple calls are made and the connection is managed externally.
+.EXAMPLE
+    PS> Get-AdminRoleUserLicense
+
+        This example retrieves all administrative role users along with their licenses by connecting to Microsoft Graph using the default scopes.
+.EXAMPLE
+    PS> Get-AdminRoleUserLicense -SkipGraphConnection
+
+        This example retrieves all administrative role users along with their licenses without attempting to connect to Microsoft Graph, assuming that the connection is already established.
+.INPUTS
+    None. You cannot pipe objects to Get-AdminRoleUserLicense.
+.OUTPUTS
+    PSCustomObject
+        Returns a custom object for each user with administrative roles that includes the following properties: RoleName, UserName, UserPrincipalName, UserId, HybridUser, and Licenses.
+.NOTES
+    Creation Date:  2024-04-15
+        Purpose/Change: Initial function development to support Microsoft 365 administrative role auditing.
+.LINK
+    https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Get-AdminRoleUserLicense
+#>
+function Get-AdminRoleUserLicense {
+    [OutputType([System.Collections.ArrayList])]
+    [CmdletBinding()]
+    param (
+        [Parameter(Mandatory = $false)]
+        [switch]$SkipGraphConnection
+    )
+
+    begin {
+        if (-not $SkipGraphConnection) {
+            Connect-MgGraph -Scopes "Directory.Read.All", "Domain.Read.All", "Policy.Read.All", "Organization.Read.All" -NoWelcome
+        }
+
+        $adminRoleUsers = [System.Collections.ArrayList]::new()
+        $userIds = [System.Collections.ArrayList]::new()
+    }
+
+    process {
+        Write-Verbose "Retrieving all admin roles"
+        $adminRoleNames = (Get-MgDirectoryRole | Where-Object { $null -ne $_.RoleTemplateId }).DisplayName
+
+        Write-Verbose "Filtering admin roles"
+        $adminRoles = Get-MgRoleManagementDirectoryRoleDefinition | Where-Object { ($adminRoleNames -contains $_.DisplayName) -and ($_.DisplayName -ne "Directory Synchronization Accounts") }
+
+        foreach ($role in $adminRoles) {
+            Write-Verbose "Processing role: $($role.DisplayName)"
+            $roleAssignments = Get-MgRoleManagementDirectoryRoleAssignment -Filter "roleDefinitionId eq '$($role.Id)'"
+
+            foreach ($assignment in $roleAssignments) {
+                Write-Verbose "Processing role assignment for principal ID: $($assignment.PrincipalId)"
+                $userDetails = Get-MgUser -UserId $assignment.PrincipalId -Property "DisplayName, UserPrincipalName, Id, OnPremisesSyncEnabled" -ErrorAction SilentlyContinue
+
+                if ($userDetails) {
+                    Write-Verbose "Retrieved user details for: $($userDetails.UserPrincipalName)"
+                    [void]($userIds.Add($userDetails.Id))
+                    [void]($adminRoleUsers.Add([PSCustomObject]@{
+                        RoleName          = $role.DisplayName
+                        UserName          = $userDetails.DisplayName
+                        UserPrincipalName = $userDetails.UserPrincipalName
+                        UserId            = $userDetails.Id
+                        HybridUser        = [bool]$userDetails.OnPremisesSyncEnabled
+                        Licenses          = $null  # Initialize as $null
+                    }))
+                }
+            }
+        }
+
+        Write-Verbose "Retrieving licenses for admin role users"
+        foreach ($userId in $userIds.ToArray() | Select-Object -Unique) {
+            $licenses = Get-MgUserLicenseDetail -UserId $userId -ErrorAction SilentlyContinue
+            if ($licenses) {
+                $licenseList = ($licenses.SkuPartNumber -join '|')
+                $adminRoleUsers.ToArray() | Where-Object { $_.UserId -eq $userId } | ForEach-Object {
+                    $_.Licenses = $licenseList
+                }
+            }
+        }
+    }
+
+    end {
+        Write-Host "Disconnecting from Microsoft Graph..." -ForegroundColor Green
+        Disconnect-MgGraph | Out-Null
+        return $adminRoleUsers
+    }
+}

source/Public/Get-MFAStatus.ps1

@@ -0,0 +1,107 @@
+<#
+    .SYNOPSIS
+        Retrieves the MFA (Multi-Factor Authentication) status for Azure Active Directory users.
+    .DESCRIPTION
+        The Get-MFAStatus function connects to Microsoft Online Service and retrieves the MFA status for all Azure Active Directory users, excluding guest accounts. Optionally, you can specify a single user by their User Principal Name (UPN) to get their MFA status.
+    .PARAMETER UserId
+        The User Principal Name (UPN) of a specific user to retrieve MFA status for. If not provided, the function retrieves MFA status for all users.
+    .EXAMPLE
+        Get-MFAStatus
+            Retrieves the MFA status for all Azure Active Directory users.
+    .EXAMPLE
+        Get-MFAStatus -UserId "example@domain.com"
+            Retrieves the MFA status for the specified user with the UPN "example@domain.com".
+    .OUTPUTS
+        System.Object
+            Returns a sorted list of custom objects containing the following properties:
+                - UserPrincipalName
+                - DisplayName
+                - MFAState
+                - MFADefaultMethod
+                - MFAPhoneNumber
+                - PrimarySMTP
+                - Aliases
+    .NOTES
+        The function requires the MSOL module to be installed and connected to your tenant.
+        Ensure that you have the necessary permissions to read user and MFA status information.
+    .LINK
+    https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Get-MFAStatus
+#>
+function Get-MFAStatus {
+    [OutputType([System.Object])]
+    [CmdletBinding()]
+    param (
+        [Parameter(Mandatory = $false)]
+        [ValidateNotNullOrEmpty()]
+        [string]$UserId,
+        [switch]$SkipMSOLConnectionChecks
+    )
+
+    begin {
+        # Connect to Microsoft Online service
+        Import-Module MSOnline -ErrorAction SilentlyContinue
+    }
+
+    process {
+        if (Get-Module MSOnline){
+            if (-not $SkipMSOLConnectionChecks) {
+                Connect-MsolService
+            }
+            Write-Host "Finding Azure Active Directory Accounts..."
+            # Get all users, excluding guests
+            $Users = if ($PSBoundParameters.ContainsKey('UserId')) {
+                Get-MsolUser -UserPrincipalName $UserId
+            } else {
+                Get-MsolUser -All | Where-Object { $_.UserType -ne "Guest" }
+            }
+            $Report = [System.Collections.Generic.List[Object]]::new() # Create output list
+            Write-Host "Processing $($Users.Count) accounts..."
+            ForEach ($User in $Users) {
+                $MFADefaultMethod = ($User.StrongAuthenticationMethods | Where-Object { $_.IsDefault -eq "True" }).MethodType
+                $MFAPhoneNumber = $User.StrongAuthenticationUserDetails.PhoneNumber
+                $PrimarySMTP = $User.ProxyAddresses | Where-Object { $_ -clike "SMTP*" } | ForEach-Object { $_ -replace "SMTP:", "" }
+                $Aliases = $User.ProxyAddresses | Where-Object { $_ -clike "smtp*" } | ForEach-Object { $_ -replace "smtp:", "" }
+
+                If ($User.StrongAuthenticationRequirements) {
+                    $MFAState = $User.StrongAuthenticationRequirements.State
+                }
+                Else {
+                    $MFAState = 'Disabled'
+                }
+
+                If ($MFADefaultMethod) {
+                    Switch ($MFADefaultMethod) {
+                        "OneWaySMS" { $MFADefaultMethod = "Text code authentication phone" }
+                        "TwoWayVoiceMobile" { $MFADefaultMethod = "Call authentication phone" }
+                        "TwoWayVoiceOffice" { $MFADefaultMethod = "Call office phone" }
+                        "PhoneAppOTP" { $MFADefaultMethod = "Authenticator app or hardware token" }
+                        "PhoneAppNotification" { $MFADefaultMethod = "Microsoft authenticator app" }
+                    }
+                }
+                Else {
+                    $MFADefaultMethod = "Not enabled"
+                }
+
+                $ReportLine = [PSCustomObject] @{
+                    UserPrincipalName = $User.UserPrincipalName
+                    DisplayName       = $User.DisplayName
+                    MFAState          = $MFAState
+                    MFADefaultMethod  = $MFADefaultMethod
+                    MFAPhoneNumber    = $MFAPhoneNumber
+                    PrimarySMTP       = ($PrimarySMTP -join ',')
+                    Aliases           = ($Aliases -join ',')
+                    isLicensed        = $User.isLicensed
+                }
+
+                $Report.Add($ReportLine)
+            }
+
+            Write-Host "Processing complete."
+            Write-Host "To disconnect from the MsolService close the powershell session or wait for the session to expire."
+            return $Report | Select-Object UserPrincipalName, DisplayName, MFAState, MFADefaultMethod, MFAPhoneNumber, PrimarySMTP, Aliases, isLicensed | Sort-Object UserPrincipalName
+        }
+        else {
+            Write-Host "You must first install MSOL using:`nInstall-Module MSOnline -Scope CurrentUser -Force"
+        }
+    }
+}

source/Public/Grant-M365SecurityAuditConsent.ps1

@@ -0,0 +1,182 @@
+<#
+    .SYNOPSIS
+    Grants Microsoft Graph permissions for an auditor.
+    .DESCRIPTION
+        This function grants the specified Microsoft Graph permissions to a user, allowing the user to perform audits. It connects to Microsoft Graph, checks if a service principal exists for the client application, creates it if it does not exist, and then grants the specified permissions. Finally, it assigns the app to the user.
+    .PARAMETER UserPrincipalNameForConsent
+        The UPN or ID of the user to grant consent for.
+    .PARAMETER SkipGraphConnection
+        If specified, skips connecting to Microsoft Graph.
+    .PARAMETER DoNotDisconnect
+        If specified, does not disconnect from Microsoft Graph after granting consent.
+    .PARAMETER SkipModuleCheck
+        If specified, skips the check for the Microsoft.Graph module.
+    .PARAMETER SuppressRevertOutput
+        If specified, suppresses the output of the revert commands.
+    .EXAMPLE
+        Grant-M365SecurityAuditConsent -UserPrincipalNameForConsent user@example.com
+
+            Grants Microsoft Graph permissions to user@example.com for the client application with the specified Application ID.
+    .EXAMPLE
+        Grant-M365SecurityAuditConsent -UserPrincipalNameForConsent user@example.com -SkipGraphConnection
+
+            Grants Microsoft Graph permissions to user@example.com, skipping the connection to Microsoft Graph.
+    .NOTES
+        This function requires the Microsoft.Graph module version 2.4.0 or higher.
+    .LINK
+        https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Grant-M365SecurityAuditConsent
+#>
+function Grant-M365SecurityAuditConsent {
+    [CmdletBinding(
+        SupportsShouldProcess = $true,
+        ConfirmImpact = 'High'
+    )]
+    [OutputType([void])]
+    param (
+        [Parameter(
+            Mandatory = $true,
+            Position = 0,
+            ValueFromPipeline = $true,
+            ValueFromPipelineByPropertyName = $true,
+            HelpMessage = 'Specify the UPN of the user to grant consent for.'
+        )]
+        [ValidatePattern('^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$')]
+        [String]$UserPrincipalNameForConsent,
+        [Parameter(
+            Mandatory = $false,
+            HelpMessage = 'Skip connecting to Microsoft Graph.'
+        )]
+        [switch]$SkipGraphConnection,
+        [Parameter(
+            Mandatory = $false,
+            HelpMessage = 'Skip the check for the Microsoft.Graph module.'
+        )]
+        [switch]$SkipModuleCheck,
+        [Parameter(
+            Mandatory = $false,
+            HelpMessage = 'Suppress the output of the revert commands.'
+        )]
+        [switch]$SuppressRevertOutput,
+        [Parameter(
+            Mandatory = $false,
+            HelpMessage = 'Do not disconnect from Microsoft Graph after granting consent.'
+        )]
+        [switch]$DoNotDisconnect
+    )
+    begin {
+        if (!($SkipModuleCheck)) {
+            Assert-ModuleAvailability -ModuleName Microsoft.Graph -RequiredVersion "2.4.0"
+        }
+        # Adjusted from: https://learn.microsoft.com/en-us/entra/identity/enterprise-apps/grant-consent-single-user?pivots=msgraph-powershell
+        # Needed: A user account with a Privileged Role Administrator, Application Administrator, or Cloud Application Administrator
+        # The app for which consent is being granted.
+        $clientAppId = "14d82eec-204b-4c2f-b7e8-296a70dab67e" # Microsoft Graph PowerShell
+        # The API to which access will be granted. Microsoft Graph PowerShell makes API
+        # requests to the Microsoft Graph API, so we'll use that here.
+        $resourceAppId = "00000003-0000-0000-c000-000000000000" # Microsoft Graph API
+        # The permissions to grant.
+        $permissions = @("Directory.Read.All", "Domain.Read.All", "Policy.Read.All", "Organization.Read.All")
+        # The user on behalf of whom access will be granted. The app will be able to access
+        # the API on behalf of this user.
+        $userUpnOrId = $UserPrincipalNameForConsent
+    }
+    process {
+        try {
+            if (-not $SkipGraphConnection -and $PSCmdlet.ShouldProcess("Scopes: User.ReadBasic.All, Application.ReadWrite.All, DelegatedPermissionGrant.ReadWrite.All, AppRoleAssignment.ReadWrite.All", "Connect-MgGraph")) {
+                # Step 0. Connect to Microsoft Graph PowerShell. We need User.ReadBasic.All to get
+                #    users' IDs, Application.ReadWrite.All to list and create service principals,
+                #    DelegatedPermissionGrant.ReadWrite.All to create delegated permission grants,
+                #    and AppRoleAssignment.ReadWrite.All to assign an app role.
+                #    WARNING: These are high-privilege permissions!
+                Write-Host "Connecting to Microsoft Graph with scopes: User.ReadBasic.All, Application.ReadWrite.All, DelegatedPermissionGrant.ReadWrite.All, AppRoleAssignment.ReadWrite.All" -ForegroundColor Yellow
+                Connect-MgGraph -Scopes ("User.ReadBasic.All Application.ReadWrite.All " + "DelegatedPermissionGrant.ReadWrite.All " + "AppRoleAssignment.ReadWrite.All") -NoWelcome
+                $context = Get-MgContext
+                Write-Host "Connected to Microsoft Graph with user: $(($context.Account)) with the authtype `"$($context.AuthType)`" for the `"$($context.Environment)`" environment." -ForegroundColor Green
+            }
+        }
+        catch {
+            throw "Connection execution aborted: $_"
+            break
+        }
+        try {
+            if ($PSCmdlet.ShouldProcess("Create Microsoft Graph API service princial if not found", "New-MgServicePrincipal")) {
+                # Step 1. Check if a service principal exists for the client application.
+                #     If one doesn't exist, create it.
+                $clientSp = Get-MgServicePrincipal -Filter "appId eq '$($clientAppId)'" -ErrorAction SilentlyContinue
+                if (-not $clientSp) {
+                    Write-Host "Client service principal not found. Creating one." -ForegroundColor Yellow
+                    $clientSp = New-MgServicePrincipal -AppId $clientAppId
+                }
+                $user = Get-MgUser -UserId $userUpnOrId
+                if (!($user)) {
+                    throw "User with UPN or ID `"$userUpnOrId`" not found."
+                }
+                Write-Verbose "User: $($user.UserPrincipalName) Found!"
+                $resourceSp = Get-MgServicePrincipal -Filter "appId eq '$($resourceAppId)'"
+                $scopeToGrant = $permissions -join " "
+                $existingGrant = Get-MgOauth2PermissionGrant -Filter "clientId eq '$($clientSp.Id)' and principalId eq '$($user.Id)' and resourceId eq '$($resourceSp.Id)'"
+            }
+            if (-not $existingGrant -and $PSCmdlet.ShouldProcess("User: $userUpnOrId for Microsoft Graph PowerShell Scopes: $($permissions -join ', ')", "New-MgOauth2PermissionGrant: Granting Consent")) {
+                # Step 2. Create a delegated permission that grants the client app access to the
+                #     API, on behalf of the user.
+                $grant = New-MgOauth2PermissionGrant -ResourceId $resourceSp.Id -Scope $scopeToGrant -ClientId $clientSp.Id -ConsentType "Principal" -PrincipalId $user.Id
+                Write-Host "Consent granted to user $($user.UserPrincipalName) for Microsoft Graph API with scopes: $((($grant.Scope) -split ' ') -join ', ')" -ForegroundColor Green
+            }
+            if ($existingGrant -and $PSCmdlet.ShouldProcess("Update existing Microsoft Graph permissions for user $userUpnOrId", "Update-MgOauth2PermissionGrant")) {
+                # Step 2. Update the existing permission grant with the new scopes.
+                Write-Host "Updating existing permission grant for user $($user.UserPrincipalName)." -ForegroundColor Yellow
+                $updatedGrant = Update-MgOauth2PermissionGrant -PermissionGrantId $existingGrant.Id -Scope $scopeToGrant -Confirm:$false
+                Write-Host "Updated permission grant with ID $($updatedGrant.Id) for scopes: $scopeToGrant" -ForegroundColor Green
+            }
+            if ($PSCmdlet.ShouldProcess("Assigning app to user $userUpnOrId", "New-MgServicePrincipalAppRoleAssignedTo")) {
+                # Step 3. Assign the app to the user. This ensures that the user can sign in if assignment
+                #     is required, and ensures that the app shows up under the user's My Apps portal.
+                if ($clientSp.AppRoles | Where-Object { $_.AllowedMemberTypes -contains "User" }) {
+                    Write-Warning "A default app role assignment cannot be created because the client application exposes user-assignable app roles. You must assign the user a specific app role for the app to be listed in the user's My Apps access panel."
+                }
+                else {
+                    # The app role ID 00000000-0000-0000-0000-000000000000 is the default app role
+                    # indicating that the app is assigned to the user, but not for any specific
+                    # app role.
+                    $assignment = New-MgServicePrincipalAppRoleAssignedTo -ServicePrincipalId $clientSp.Id -ResourceId $clientSp.Id -PrincipalId $user.Id -AppRoleId "00000000-0000-0000-0000-000000000000"
+                    # $assignments = Get-MgServicePrincipalAppRoleAssignedTo -ServicePrincipalId $assignment.ResourceId -All -WhatIf
+                }
+            }
+        }
+        catch {
+            throw "An error occurred while granting consent:`n$_"
+        }
+        finally {
+            if (!($DoNotDisconnect) -and $PSCmdlet.ShouldProcess("Disconnect from Microsoft Graph", "Disconnect")) {
+                # Clean up sessions
+                Write-Host "Disconnecting from Microsoft Graph." -ForegroundColor Yellow
+                Disconnect-MgGraph | Out-Null
+            }
+        }
+    }
+    end {
+        if (-not $SuppressRevertOutput -and $PSCmdlet.ShouldProcess("Instructions to undo this change", "Generate Revert Commands")) {
+            <#
+                # Instructions to revert the changes made by this script
+                $resourceAppId = "00000003-0000-0000-c000-000000000000"
+                $clientAppId = "14d82eec-204b-4c2f-b7e8-296a70dab67e"
+                # Get the user object
+                #$user = Get-MgUser -UserId "user@example.com"
+                $resourceSp = Get-MgServicePrincipal -Filter "appId eq '$($resourceAppId)'"
+                # Get the service principal using $clientAppId
+                $clientSp = Get-MgServicePrincipal -Filter "appId eq '$($clientAppId)'"
+                $existingGrant = Get-MgOauth2PermissionGrant -Filter "clientId eq '$($clientSp.Id)' and principalId eq '$($user.Id)' and resourceId eq '$($resourceSp.Id)'"
+                # Get all app role assignments for the service principal
+                $appRoleAssignments = Get-MgServicePrincipalAppRoleAssignedTo -ServicePrincipalId $clientSp.Id -All
+                # At index of desired user assignment
+                Remove-MgServicePrincipalAppRoleAssignedTo -AppRoleAssignmentId $appRoleAssignments[1].Id -ServicePrincipalId $clientSp.Id
+                Remove-MgOAuth2PermissionGrant -OAuth2PermissionGrantId  $existingGrant.Id
+            #>
+            Write-Host "App assigned to user $($assignment.PrincipalDisplayName) for $($assignment.ResourceDisplayName) at $($assignment.CreatedDateTime)." -ForegroundColor Green
+            Write-Host "If you made a mistake and would like to remove the assignement for `"$($user.UserPrincipalName)`", you can run the following:`n" -ForegroundColor Yellow
+            Write-Host "Connect-MgGraph -Scopes (`"User.ReadBasic.All Application.ReadWrite.All `" + `"DelegatedPermissionGrant.ReadWrite.All `" + `"AppRoleAssignment.ReadWrite.All`")" -ForegroundColor Cyan
+            Write-Host "Remove-MgServicePrincipalAppRoleAssignedTo -AppRoleAssignmentId `"$($assignment.Id)`" -ServicePrincipalId `"$($assignment.ResourceId)`"" -ForegroundColor Cyan
+            Write-Host "Remove-MgOAuth2PermissionGrant -OAuth2PermissionGrantId `"$($grant.Id)`"" -ForegroundColor Cyan
+        }
+    }
+}

source/Public/Invoke-M365SecurityAudit.ps1

@@ -1,54 +1,84 @@
 <#
     .SYNOPSIS
-    Invokes a security audit for Microsoft 365 environments.
+        Invokes a security audit for Microsoft 365 environments.
     .DESCRIPTION
-    The Invoke-M365SecurityAudit cmdlet performs a comprehensive security audit based on the specified parameters. It allows auditing of various configurations and settings within a Microsoft 365 environment, such as compliance with CIS benchmarks.
+        The Invoke-M365SecurityAudit cmdlet performs a comprehensive security audit based on the specified parameters.
+        It allows auditing of various configurations and settings within a Microsoft 365 environment in alignment with CIS benchmarks designated "Automatic".
     .PARAMETER TenantAdminUrl
-    The URL of the tenant admin. This parameter is mandatory.
+        The URL of the tenant admin. If not specified, none of the SharePoint Online tests will run.
     .PARAMETER DomainName
-    The domain name of the Microsoft 365 environment. This parameter is mandatory.
+        The domain name of the Microsoft 365 environment to test. It is optional and will trigger various tests to run only for the specified domain.
+            Tests Affected: 2.1.9/Test-EnableDKIM, 1.3.1/Test-PasswordNeverExpirePolicy, 2.1.4/Test-SafeAttachmentsPolicy
     .PARAMETER ELevel
-    Specifies the E-Level (E3 or E5) for the audit. This parameter is optional and can be combined with the ProfileLevel parameter.
+        Specifies the E-Level (E3 or E5) for the audit. This parameter is optional and can be combined with the ProfileLevel parameter.
     .PARAMETER ProfileLevel
-    Specifies the profile level (L1 or L2) for the audit. This parameter is optional and can be combined with the ELevel parameter.
+        Specifies the profile level (L1 or L2) for the audit. This parameter is mandatory, but only when ELevel is selected. Otherwise it is not required.
     .PARAMETER IncludeIG1
-    If specified, includes tests where IG1 is true.
+        If specified, includes tests where IG1 is true.
     .PARAMETER IncludeIG2
-    If specified, includes tests where IG2 is true.
+        If specified, includes tests where IG2 is true.
     .PARAMETER IncludeIG3
-    If specified, includes tests where IG3 is true.
+        If specified, includes tests where IG3 is true.
     .PARAMETER IncludeRecommendation
-    Specifies specific recommendations to include in the audit. Accepts an array of recommendation numbers.
+        Specifies specific recommendations to include in the audit. Accepts an array of recommendation numbers.
     .PARAMETER SkipRecommendation
-    Specifies specific recommendations to exclude from the audit. Accepts an array of recommendation numbers.
+        Specifies specific recommendations to exclude from the audit. Accepts an array of recommendation numbers.
+    .PARAMETER ApprovedCloudStorageProviders
+        Specifies the approved cloud storage providers for the audit. Accepts an array of cloud storage provider names for test 8.1.1/Test-TeamsExternalFileSharing.
+            Acceptable values: 'GoogleDrive', 'ShareFile', 'Box', 'DropBox', 'Egnyte'
+    .PARAMETER ApprovedFederatedDomains
+        Specifies the approved federated domains for the audit test 8.2.1/Test-TeamsExternalAccess. Accepts an array of allowed domain names.
+            Additional Tests may include this parameter in the future.
     .PARAMETER DoNotConnect
-    If specified, the cmdlet will not establish a connection to Microsoft 365 services.
+        If specified, the cmdlet will not establish a connection to Microsoft 365 services.
     .PARAMETER DoNotDisconnect
-    If specified, the cmdlet will not disconnect from Microsoft 365 services after execution.
+        If specified, the cmdlet will not disconnect from Microsoft 365 services after execution.
     .PARAMETER NoModuleCheck
-    If specified, the cmdlet will not check for the presence of required modules.
+        If specified, the cmdlet will not check for the presence of required modules.
+    .PARAMETER DoNotConfirmConnections
+        If specified, the cmdlet will not prompt for confirmation before proceeding with established connections and will disconnect from all of them.
+    .PARAMETER AuthParams
+        Specifies an authentication object containing parameters for application-based authentication. If provided, this will be used for connecting to services.
     .EXAMPLE
-    PS> Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -ELevel "E5" -ProfileLevel "L1"
-
-    Performs a security audit for the E5 level and L1 profile in the specified Microsoft 365 environment.
+        PS> Invoke-M365SecurityAudit
+            # Performs a security audit using default parameters.
     .EXAMPLE
-    PS> Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -IncludeIG1
-
-    Performs an audit including all tests where IG1 is true.
+        PS> Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -ELevel "E5" -ProfileLevel "L1"
+            # Performs a security audit for the E5 level and L1 profile in the specified Microsoft 365 environment.
     .EXAMPLE
-    PS> Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -SkipRecommendation '1.1.3', '2.1.1'
-
-    Performs an audit while excluding specific recommendations 1.1.3 and 2.1.1.
+        PS> Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -IncludeIG1
+            # Performs a security audit while including tests where IG1 is true.
     .EXAMPLE
-    PS> $auditResults = Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com"
-    PS> $auditResults | Export-Csv -Path "auditResults.csv" -NoTypeInformation
-
-    Captures the audit results into a variable and exports them to a CSV file.
+        PS> Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -SkipRecommendation '1.1.3', '2.1.1'
+            # Performs an audit while excluding specific recommendations 1.1.3 and 2.1.1.
+    .EXAMPLE
+        PS> $auditResults = Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com"
+        PS> Export-M365SecurityAuditTable -AuditResults $auditResults -ExportPath "C:\temp" -ExportOriginalTests -ExportAllTests
+    .EXAMPLE
+        # (PowerShell 7.x Only) Creating a new authentication object for the security audit for app-based authentication.
+        PS> $authParams = New-M365SecurityAuditAuthObject `
+                -ClientCertThumbPrint "ABCDEF1234567890ABCDEF1234567890ABCDEF12" `
+                -ClientId "12345678-1234-1234-1234-123456789012" `
+                -TenantId "12345678-1234-1234-1234-123456789012" `
+                -OnMicrosoftUrl "yourcompany.onmicrosoft.com" `
+                -SpAdminUrl "https://yourcompany-admin.sharepoint.com"
+            Invoke-M365SecurityAudit -AuthParams $authParams -TenantAdminUrl "https://yourcompany-admin.sharepoint.com"
+        # Or:
+        PS> $auditResults | Export-Csv -Path "auditResults.csv" -NoTypeInformation
+            # Captures the audit results into a variable and exports them to a CSV file (Nested tables will be truncated).
+                Output:
+                    CISAuditResult[]
+                    auditResults.csv
+    .EXAMPLE
+        PS> Invoke-M365SecurityAudit -WhatIf
+            Displays what would happen if the cmdlet is run without actually performing the audit.
+                Output:
+                    What if: Performing the operation "Invoke-M365SecurityAudit" on target "Microsoft 365 environment".
     .INPUTS
-    None. You cannot pipe objects to Invoke-M365SecurityAudit.
+        None. You cannot pipe objects to Invoke-M365SecurityAudit.
     .OUTPUTS
-    CISAuditResult[]
-    The cmdlet returns an array of CISAuditResult objects representing the results of the security audit.
+        CISAuditResult[]
+            The cmdlet returns an array of CISAuditResult objects representing the results of the security audit.
     .NOTES
         - This module is based on CIS benchmarks.
         - Governed by the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
@@ -57,42 +87,37 @@
         - For full license details, visit: https://creativecommons.org/licenses/by-nc-sa/4.0/deed.en
         - Register for CIS Benchmarks at: https://www.cisecurity.org/cis-benchmarks
     .LINK
-    Online Version: https://github.com/CriticalSolutionsNetwork/M365FoundationsCISReport
+        https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Invoke-M365SecurityAudit
 #>
-
 function Invoke-M365SecurityAudit {
-    [CmdletBinding(SupportsShouldProcess = $true, DefaultParameterSetName = 'Default')]
+    # Add confirm to high
+    [CmdletBinding(SupportsShouldProcess = $true, ConfirmImpact = "High" , DefaultParameterSetName = 'Default')]
     [OutputType([CISAuditResult[]])]
     param (
-        [Parameter(Mandatory = $true)]
+        [Parameter(Mandatory = $false, HelpMessage = "The SharePoint tenant admin URL, which should end with '-admin.sharepoint.com'. If not specified none of the Sharepoint Online tests will run.")]
+        [ValidatePattern('^https://[a-zA-Z0-9-]+-admin\.sharepoint\.com$')]
         [string]$TenantAdminUrl,
-
-        [Parameter(Mandatory = $true)]
+        [Parameter(Mandatory = $false, HelpMessage = "Specify this to test only the default domain for password expiration and DKIM Config for tests '1.3.1' and 2.1.9. The domain name of your organization, e.g., 'example.com'.")]
+        [ValidatePattern('^[a-zA-Z0-9-]+\.[a-zA-Z]{2,}$')]
         [string]$DomainName,
-
         # E-Level with optional ProfileLevel selection
-        [Parameter(ParameterSetName = 'ELevelFilter')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'ELevelFilter', HelpMessage = "Specifies the E-Level (E3 or E5) for the audit.")]
         [ValidateSet('E3', 'E5')]
         [string]$ELevel,
-
-        [Parameter(ParameterSetName = 'ELevelFilter')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'ELevelFilter', HelpMessage = "Specifies the profile level (L1 or L2) for the audit.")]
         [ValidateSet('L1', 'L2')]
         [string]$ProfileLevel,
-
         # IG Filters, one at a time
-        [Parameter(ParameterSetName = 'IG1Filter')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'IG1Filter', HelpMessage = "Includes tests where IG1 is true.")]
         [switch]$IncludeIG1,
-
-        [Parameter(ParameterSetName = 'IG2Filter')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'IG2Filter', HelpMessage = "Includes tests where IG2 is true.")]
         [switch]$IncludeIG2,
-
-        [Parameter(ParameterSetName = 'IG3Filter')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'IG3Filter', HelpMessage = "Includes tests where IG3 is true.")]
         [switch]$IncludeIG3,
-
         # Inclusion of specific recommendation numbers
-        [Parameter(ParameterSetName = 'RecFilter')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'RecFilter', HelpMessage = "Specifies specific recommendations to include in the audit. Accepts an array of recommendation numbers.")]
         [ValidateSet(
-            '1.1.3', '1.2.1', '1.2.2', '1.3.1', '1.3.3', '1.3.6', '2.1.1', '2.1.2', `
+            '1.1.1', '1.1.3', '1.2.1', '1.2.2', '1.3.1', '1.3.3', '1.3.6', '2.1.1', '2.1.2', `
                 '2.1.3', '2.1.4', '2.1.5', '2.1.6', '2.1.7', '2.1.9', '3.1.1', '5.1.2.3', `
                 '5.1.8.1', '6.1.1', '6.1.2', '6.1.3', '6.2.1', '6.2.2', '6.2.3', '6.3.1', `
                 '6.5.1', '6.5.2', '6.5.3', '7.2.1', '7.2.10', '7.2.2', '7.2.3', '7.2.4', `
@@ -101,11 +126,10 @@ function Invoke-M365SecurityAudit {
                 '8.5.7', '8.6.1'
         )]
         [string[]]$IncludeRecommendation,
-
         # Exclusion of specific recommendation numbers
-        [Parameter(ParameterSetName = 'SkipRecFilter')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'SkipRecFilter', HelpMessage = "Specifies specific recommendations to exclude from the audit. Accepts an array of recommendation numbers.")]
         [ValidateSet(
-            '1.1.3', '1.2.1', '1.2.2', '1.3.1', '1.3.3', '1.3.6', '2.1.1', '2.1.2', `
+            '1.1.1', '1.1.3', '1.2.1', '1.2.2', '1.3.1', '1.3.3', '1.3.6', '2.1.1', '2.1.2', `
                 '2.1.3', '2.1.4', '2.1.5', '2.1.6', '2.1.7', '2.1.9', '3.1.1', '5.1.2.3', `
                 '5.1.8.1', '6.1.1', '6.1.2', '6.1.3', '6.2.1', '6.2.2', '6.2.3', '6.3.1', `
                 '6.5.1', '6.5.2', '6.5.3', '7.2.1', '7.2.10', '7.2.2', '7.2.3', '7.2.4', `
@@ -114,146 +138,153 @@ function Invoke-M365SecurityAudit {
                 '8.5.7', '8.6.1'
         )]
         [string[]]$SkipRecommendation,
-
         # Common parameters for all parameter sets
+        [Parameter(Mandatory = $false, HelpMessage = "Specifies the approved cloud storage providers for the audit. Accepts an array of cloud storage provider names.")]
+        [ValidateSet(
+            'GoogleDrive', 'ShareFile', 'Box', 'DropBox', 'Egnyte'
+        )]
+        [string[]]$ApprovedCloudStorageProviders = @(),
+        [Parameter(Mandatory = $false, HelpMessage = "Specifies the approved federated domains for the audit test 8.2.1. Accepts an array of allowed domain names.")]
+        [ValidatePattern('^[a-zA-Z0-9-]+\.[a-zA-Z]{2,}$')]
+        [string[]]$ApprovedFederatedDomains,
+        [Parameter(Mandatory = $false, HelpMessage = "Specifies that the cmdlet will not establish a connection to Microsoft 365 services.")]
         [switch]$DoNotConnect,
+        [Parameter(Mandatory = $false, HelpMessage = "Specifies that the cmdlet will not disconnect from Microsoft 365 services after execution.")]
         [switch]$DoNotDisconnect,
-        [switch]$NoModuleCheck
+        [Parameter(Mandatory = $false, HelpMessage = "Specifies that the cmdlet will not check for the presence of required modules.")]
+        [switch]$NoModuleCheck,
+        [Parameter(Mandatory = $false, HelpMessage = "Specifies that the cmdlet will not prompt for confirmation before proceeding with established connections and will disconnect from all of them.")]
+        [switch]$DoNotConfirmConnections,
+        [Parameter(Mandatory = $false, HelpMessage = "Specifies an authentication object containing parameters for application-based authentication.")]
+        [CISAuthenticationParameters]$AuthParams
     )
-
-
-
     Begin {
         if ($script:MaximumFunctionCount -lt 8192) {
+            Write-Verbose "Setting the `$script:MaximumFunctionCount to 8192 for the test run."
             $script:MaximumFunctionCount = 8192
         }
+        if ($AuthParams) {
+            $script:PnpAuth = $true
+        }
         # Ensure required modules are installed
-        # Define the required modules and versions in a hashtable
-        if (!($NoModuleCheck)) {
-            $requiredModules = @(
-                @{ ModuleName = "ExchangeOnlineManagement"; RequiredVersion = "3.3.0" },
-                @{ ModuleName = "AzureAD"; RequiredVersion = "2.0.2.182" },
-                @{ ModuleName = "Microsoft.Graph"; RequiredVersion = "2.4.0"; SubModuleName = "Authentication" },
-                @{ ModuleName = "Microsoft.Graph"; RequiredVersion = "2.4.0"; SubModuleName = "Users" },
-                @{ ModuleName = "Microsoft.Graph"; RequiredVersion = "2.4.0"; SubModuleName = "Groups" },
-                @{ ModuleName = "Microsoft.Graph"; RequiredVersion = "2.4.0"; SubModuleName = "DirectoryObjects" },
-                @{ ModuleName = "Microsoft.Graph"; RequiredVersion = "2.4.0"; SubModuleName = "Domains" },
-                @{ ModuleName = "Microsoft.Graph"; RequiredVersion = "2.4.0"; SubModuleName = "Reports" },
-                @{ ModuleName = "Microsoft.Graph"; RequiredVersion = "2.4.0"; SubModuleName = "Mail" },
-                @{ ModuleName = "Microsoft.Online.SharePoint.PowerShell"; RequiredVersion = "16.0.24009.12000" },
-                @{ ModuleName = "MicrosoftTeams"; RequiredVersion = "5.5.0" }
-            )
+        $requiredModules = Get-RequiredModule -AuditFunction
+        # Format the required modules list
+        $requiredModulesFormatted = Format-RequiredModuleList -RequiredModules $requiredModules
+        # Check and install required modules if necessary
+        if (!($NoModuleCheck) -and $PSCmdlet.ShouldProcess("Modules: $requiredModulesFormatted", "Assert-ModuleAvailability")) {
+            Write-Information "Checking for and installing required modules..."
             foreach ($module in $requiredModules) {
-                Assert-ModuleAvailability -ModuleName $module.ModuleName -RequiredVersion $module.RequiredVersion -SubModuleName $module.SubModuleName
+                Assert-ModuleAvailability -ModuleName $module.ModuleName -RequiredVersion $module.RequiredVersion -SubModules $module.SubModules
             }
         }
-
-
-        # Loop through each required module and assert its availability
-
-        # Establishing connections
-        #if (!($DoNotConnect -or $DoNotTest)) {
-        # Establishing connections
-        if (!($DoNotConnect)) {
-            Connect-M365Suite -TenantAdminUrl $TenantAdminUrl
-        }
-
         # Load test definitions from CSV
         $testDefinitionsPath = Join-Path -Path $PSScriptRoot -ChildPath "helper\TestDefinitions.csv"
         $testDefinitions = Import-Csv -Path $testDefinitionsPath
-
+        # Load the Test Definitions into the script scope for use in other functions
+        $script:TestDefinitionsObject = $testDefinitions
         # Apply filters based on parameter sets
-        switch ($PSCmdlet.ParameterSetName) {
-            'ELevelFilter' {
-                if ($null -ne $ELevel -and $null -ne $ProfileLevel) {
-                    $testDefinitions = $testDefinitions | Where-Object {
-                        $_.ELevel -eq $ELevel -and $_.ProfileLevel -eq $ProfileLevel
-                    }
+        $params = @{
+            TestDefinitions       = $testDefinitions
+            ParameterSetName      = $PSCmdlet.ParameterSetName
+            ELevel                = $ELevel
+            ProfileLevel          = $ProfileLevel
+            IncludeRecommendation = $IncludeRecommendation
+            SkipRecommendation    = $SkipRecommendation
+        }
+        $testDefinitions = Get-TestDefinitionsObject @params
+        # Extract unique connections needed
+        $requiredConnections = $testDefinitions.Connection | Sort-Object -Unique
+        if ($requiredConnections -contains 'SPO') {
+            if (-not $TenantAdminUrl) {
+                $requiredConnections = $requiredConnections | Where-Object { $_ -ne 'SPO' }
+                $testDefinitions = $testDefinitions | Where-Object { $_.Connection -ne 'SPO' }
+                if ($null -eq $testDefinitions) {
+                    throw "No tests to run as no SharePoint Online tests are available."
                 }
-                elseif ($null -ne $ELevel) {
-                    $testDefinitions = $testDefinitions | Where-Object {
-                        $_.ELevel -eq $ELevel
-                    }
-                }
-                elseif ($null -ne $ProfileLevel) {
-                    $testDefinitions = $testDefinitions | Where-Object {
-                        $_.ProfileLevel -eq $ProfileLevel
-                    }
-                }
-            }
-            'IG1Filter' {
-                $testDefinitions = $testDefinitions | Where-Object { $_.IG1 -eq 'TRUE' }
-            }
-            'IG2Filter' {
-                $testDefinitions = $testDefinitions | Where-Object { $_.IG2 -eq 'TRUE' }
-            }
-            'IG3Filter' {
-                $testDefinitions = $testDefinitions | Where-Object { $_.IG3 -eq 'TRUE' }
-            }
-            'RecFilter' {
-                $testDefinitions = $testDefinitions | Where-Object { $IncludeRecommendation -contains $_.Rec }
-            }
-            'SkipRecFilter' {
-                $testDefinitions = $testDefinitions | Where-Object { $SkipRecommendation -notcontains $_.Rec }
             }
         }
-        # End switch ($PSCmdlet.ParameterSetName)
-
         # Determine which test files to load based on filtering
         $testsToLoad = $testDefinitions.TestFileName | ForEach-Object { $_ -replace '.ps1$', '' }
-
-        # Display the tests that would be loaded if the function is called with -WhatIf
-
         Write-Verbose "The $(($testsToLoad).count) test/s that would be loaded based on filter criteria:"
         $testsToLoad | ForEach-Object { Write-Verbose " $_" }
+        # Initialize a collection to hold failed test details
+        $script:FailedTests = [System.Collections.ArrayList]::new()
     } # End Begin
-
     Process {
-        $allAuditResults = @()  # Initialize a collection to hold all results
-
+        $allAuditResults = [System.Collections.ArrayList]::new() # Initialize a collection to hold all results
         # Dynamically dot-source the test scripts
         $testsFolderPath = Join-Path -Path $PSScriptRoot -ChildPath "tests"
         $testFiles = Get-ChildItem -Path $testsFolderPath -Filter "Test-*.ps1" |
         Where-Object { $testsToLoad -contains $_.BaseName }
-
-        # Import the test functions
-        $testFiles | ForEach-Object {
-            Try {
-                . $_.FullName
-            }
-            Catch {
-                Write-Error "Failed to load test function $($_.Name): $_"
+        $totalTests = $testFiles.Count
+        $currentTestIndex = 0
+        # Establishing connections if required
+        try {
+            $actualUniqueConnections = Get-UniqueConnection -Connections $requiredConnections
+            if (!($DoNotConnect) -and $PSCmdlet.ShouldProcess("Establish connections to Microsoft 365 services: $($actualUniqueConnections -join ', ')", "Connect")) {
+                Write-Information "Establishing connections to Microsoft 365 services: $($actualUniqueConnections -join ', ')"
+                Connect-M365Suite -TenantAdminUrl $TenantAdminUrl -RequiredConnections $requiredConnections -SkipConfirmation:$DoNotConfirmConnections -AuthParams $AuthParams
             }
         }
-
-        # Execute each test function from the prepared list
-        foreach ($testFunction in $testFiles) {
-            $functionName = $testFunction.BaseName
-            $functionCmd = Get-Command -Name $functionName
-
-            # Check if the test function needs DomainName parameter
-            $paramList = @{}
-            if ('DomainName' -in $functionCmd.Parameters.Keys) {
-                $paramList.DomainName = $DomainName
+        catch {
+            Throw "Connection execution aborted: $_"
+        }
+        try {
+            if ($PSCmdlet.ShouldProcess("Measure and display audit results for $($totalTests) tests", "Measure")) {
+                Write-Information "A total of $($totalTests) tests were selected to run..."
+                # Import the test functions
+                $testFiles | ForEach-Object {
+                    $currentTestIndex++
+                    Write-Progress -Activity "Loading Test Scripts" -Status "Loading $($currentTestIndex) of $($totalTests): $($_.Name)" -PercentComplete (($currentTestIndex / $totalTests) * 100)
+                    Try {
+                        # Dot source the test function
+                        . $_.FullName
+                    }
+                    Catch {
+                        # Log the error and add the test to the failed tests collection
+                        Write-Verbose "Failed to load test function $($_.Name): $_"
+                        $script:FailedTests.Add([PSCustomObject]@{ Test = $_.Name; Error = $_ })
+                    }
+                }
+                $currentTestIndex = 0
+                # Execute each test function from the prepared list
+                foreach ($testFunction in $testFiles) {
+                    $currentTestIndex++
+                    Write-Progress -Activity "Executing Tests" -Status "Executing $($currentTestIndex) of $($totalTests): $($testFunction.Name)" -PercentComplete (($currentTestIndex / $totalTests) * 100)
+                    $functionName = $testFunction.BaseName
+                    Write-Information "Executing test function: $functionName"
+                    $auditResult = Invoke-TestFunction -FunctionFile $testFunction -DomainName $DomainName -ApprovedCloudStorageProviders $ApprovedCloudStorageProviders -ApprovedFederatedDomains $ApprovedFederatedDomains
+                    # Add the result to the collection
+                    [void]$allAuditResults.Add($auditResult)
+                }
+                # Call the private function to calculate and display results
+                Measure-AuditResult -AllAuditResults $allAuditResults -FailedTests $script:FailedTests
+                # Return all collected audit results
+                # Define the test numbers to check
+                $TestNumbersToCheck = "1.1.1", "1.3.1", "6.1.2", "6.1.3", "7.3.4"
+                # Check for large details in the audit results
+                $exceedingTests = Get-ExceededLengthResultDetail -AuditResults $allAuditResults -TestNumbersToCheck $TestNumbersToCheck -ReturnExceedingTestsOnly -DetailsLengthLimit 30000
+                if ($exceedingTests.Count -gt 0) {
+                    Write-Information "The following tests exceeded the details length limit: $($exceedingTests -join ', ')"
+                    Write-Information "( Assuming the results were instantiated. Ex: `$object = invoke-M365SecurityAudit )`nUse the following command and adjust as necessary to view the full details of the test results:"
+                    Write-Information "Export-M365SecurityAuditTable -ExportAllTests -AuditResults `$object -ExportPath `"C:\temp`" -ExportOriginalTests"
+                }
+                return $allAuditResults.ToArray() | Sort-Object -Property Rec
             }
-
-            # Use splatting to pass parameters
-            if ($PSCmdlet.ShouldProcess($functionName, "Execute test")) {
-                Write-Host "Running $functionName..."
-                $result = & $functionName @paramList
-                # Assuming each function returns an array of CISAuditResult or a single CISAuditResult
-                $allAuditResults += $result
+        }
+        catch {
+            # Log the error and add the test to the failed tests collection
+            throw "Failed to execute test function $($testFunction.Name): $_"
+            $script:FailedTests.Add([PSCustomObject]@{ Test = $_.Name; Error = $_ })
+        }
+        finally {
+            if (!($DoNotDisconnect) -and $PSCmdlet.ShouldProcess("Disconnect from Microsoft 365 services: $($actualUniqueConnections -join ', ')", "Disconnect")) {
+                # Clean up sessions
+                Disconnect-M365Suite -RequiredConnections $requiredConnections
             }
         }
     }
-
     End {
-        # Return all collected audit results
-        return $allAuditResults
-        # Check if the Disconnect switch is present
-        if (!($DoNotDisconnect)) {
-            # Clean up sessions
-            Disconnect-M365Suite
-        }
+
     }
-}
+}

source/Public/New-M365SecurityAuditAuthObject.ps1

@@ -0,0 +1,64 @@
+<#
+    .SYNOPSIS
+        Creates a new CISAuthenticationParameters object for Microsoft 365 authentication.
+    .DESCRIPTION
+        The New-M365SecurityAuditAuthObject function constructs a new CISAuthenticationParameters object
+        containing the necessary credentials and URLs for authenticating to various Microsoft 365 services.
+        It validates input parameters to ensure they conform to expected formats and length requirements.
+        An app registration in Azure AD with the required permissions to EXO, SPO, MSTeams and MgGraph is needed.
+    .PARAMETER ClientCertThumbPrint
+        The thumbprint of the client certificate used for authentication. It must be a 40-character hexadecimal string.
+        This certificate is used to authenticate the application in Azure AD.
+    .PARAMETER ClientId
+        The Client ID (Application ID) of the Azure AD application. It must be a valid GUID format.
+    .PARAMETER TenantId
+        The Tenant ID of the Azure AD directory. It must be a valid GUID format representing your Microsoft 365 tenant.
+    .PARAMETER OnMicrosoftUrl
+        The URL of your onmicrosoft.com domain. It should be in the format 'example.onmicrosoft.com'.
+    .PARAMETER SpAdminUrl
+        The SharePoint admin URL, which should end with '-admin.sharepoint.com'. This URL is used for connecting to SharePoint Online.
+    .INPUTS
+        None. You cannot pipe objects to this function.
+    .OUTPUTS
+        CISAuthenticationParameters
+            The function returns an instance of the CISAuthenticationParameters class containing the authentication details.
+    .EXAMPLE
+        PS> $authParams = New-M365SecurityAuditAuthObject -ClientCertThumbPrint "ABCDEF1234567890ABCDEF1234567890ABCDEF12" `
+                                                            -ClientId "12345678-1234-1234-1234-123456789012" `
+                                                            -TenantId "12345678-1234-1234-1234-123456789012" `
+                                                            -OnMicrosoftUrl "yourcompany.onmicrosoft.com" `
+                                                            -SpAdminUrl "https://yourcompany-admin.sharepoint.com"
+        Creates a new CISAuthenticationParameters object with the specified credentials and URLs, validating each parameter's format and length.
+    .NOTES
+        Requires PowerShell 7.0 or later.
+#>
+function New-M365SecurityAuditAuthObject {
+    [CmdletBinding()]
+    [OutputType([CISAuthenticationParameters])]
+    param(
+        [Parameter(Mandatory = $true, HelpMessage = "The 40-character hexadecimal thumbprint of the client certificate.")]
+        [ValidatePattern("^[0-9a-fA-F]{40}$")]  # Regex for a valid thumbprint format
+        [ValidateLength(40, 40)]  # Enforce exact length
+        [string]$ClientCertThumbPrint,
+        [Parameter(Mandatory = $true, HelpMessage = "The Client ID (GUID format) of the Azure AD application.")]
+        [ValidatePattern("^[0-9a-fA-F\-]{36}$")]  # Regex for a valid GUID
+        [string]$ClientId,
+        [Parameter(Mandatory = $true, HelpMessage = "The Tenant ID (GUID format) of the Azure AD directory.")]
+        [ValidatePattern("^[0-9a-fA-F\-]{36}$")]  # Regex for a valid GUID
+        [string]$TenantId,
+        [Parameter(Mandatory = $true, HelpMessage = "The onmicrosoft.com domain URL (e.g., 'example.onmicrosoft.com').")]
+        [ValidatePattern("^[a-zA-Z0-9]+\.onmicrosoft\.com$")]  # Regex for a valid onmicrosoft.com URL
+        [string]$OnMicrosoftUrl,
+        [Parameter(Mandatory = $true, HelpMessage = "The SharePoint admin URL ending with '-admin.sharepoint.com'.")]
+        [ValidatePattern("^https:\/\/[a-zA-Z0-9\-]+\-admin\.sharepoint\.com$")]  # Regex for a valid SharePoint admin URL
+        [string]$SpAdminUrl
+    )
+    # Create and return the authentication parameters object
+    return [CISAuthenticationParameters]::new(
+        $ClientCertThumbPrint,
+        $ClientId,
+        $TenantId,
+        $OnMicrosoftUrl,
+        $SpAdminUrl
+    )
+}

source/Public/Remove-RowsWithEmptyCSVStatus.ps1

@@ -0,0 +1,42 @@
+<#
+    .SYNOPSIS
+        Removes rows from an Excel worksheet where the 'CSV_Status' column is empty and saves the result to a new file.
+    .DESCRIPTION
+        The Remove-RowsWithEmptyCSVStatus function imports data from a specified worksheet in an Excel file, checks for the presence of the 'CSV_Status' column, and filters out rows where the 'CSV_Status' column is empty. The filtered data is then exported to a new Excel file with a '-Filtered' suffix added to the original file name.
+    .PARAMETER FilePath
+        The path to the Excel file to be processed.
+    .PARAMETER WorksheetName
+        The name of the worksheet within the Excel file to be processed.
+    .EXAMPLE
+        PS C:\> Remove-RowsWithEmptyCSVStatus -FilePath "C:\Reports\Report.xlsx" -WorksheetName "Sheet1"
+            This command imports data from the "Sheet1" worksheet in the "Report.xlsx" file, removes rows where the 'CSV_Status' column is empty, and saves the filtered data to a new file named "Report-Filtered.xlsx" in the same directory.
+    .NOTES
+        This function requires the ImportExcel module to be installed.
+#>
+function Remove-RowsWithEmptyCSVStatus {
+    [CmdletBinding()]
+    param (
+        [Parameter(Mandatory = $true)]
+        [string]$FilePath,
+
+        [Parameter(Mandatory = $true)]
+        [string]$WorksheetName
+    )
+    # Import the Excel file
+    $ExcelData = Import-Excel -Path $FilePath -WorksheetName $WorksheetName
+    # Check if CSV_Status column exists
+    if (-not $ExcelData.PSObject.Properties.Match("CSV_Status")) {
+        throw "CSV_Status column not found in the worksheet."
+    }
+    # Filter rows where CSV_Status is not empty
+    $FilteredData = $ExcelData | Where-Object { $null -ne $_.CSV_Status -and $_.CSV_Status -ne '' }
+    # Get the original file name and directory
+    $OriginalFileName = [System.IO.Path]::GetFileNameWithoutExtension($FilePath)
+    $Directory = [System.IO.Path]::GetDirectoryName($FilePath)
+    # Create a new file name for the filtered data
+    $NewFileName = "$OriginalFileName-Filtered.xlsx"
+    $NewFilePath = Join-Path -Path $Directory -ChildPath $NewFileName
+    # Export the filtered data to a new Excel file
+    $FilteredData | Export-Excel -Path $NewFilePath -WorksheetName $WorksheetName -Show
+    Write-Output "Filtered Excel file created at $NewFilePath"
+}

source/Public/Sync-CISExcelAndCsvData.ps1

@@ -0,0 +1,102 @@
+<#
+    .SYNOPSIS
+        Synchronizes and updates data in an Excel worksheet with new information from a CSV file, including audit dates.
+    .DESCRIPTION
+        The Sync-CISExcelAndCsvData function merges and updates data in a specified Excel worksheet from a CSV file. This includes adding or updating fields for connection status, details, failure reasons, and the date of the update. It's designed to ensure that the Excel document maintains a running log of changes over time, ideal for tracking remediation status and audit history.
+    .PARAMETER ExcelPath
+        Specifies the path to the Excel file to be updated. This parameter is mandatory.
+    .PARAMETER CsvPath
+        Specifies the path to the CSV file containing new data. This parameter is mandatory.
+    .PARAMETER SheetName
+        Specifies the name of the worksheet in the Excel file where data will be merged and updated. This parameter is mandatory.
+    .EXAMPLE
+        PS> Sync-CISExcelAndCsvData -ExcelPath "path\to\excel.xlsx" -CsvPath "path\to\data.csv" -SheetName "AuditData"
+            Updates the 'AuditData' worksheet in 'excel.xlsx' with data from 'data.csv', adding new information and the date of the update.
+    .INPUTS
+        System.String
+            The function accepts strings for file paths and worksheet names.
+    .OUTPUTS
+    None
+    The function directly updates the Excel file and does not output any objects.
+    .NOTES
+        - Ensure that the 'ImportExcel' module is installed and up to date to handle Excel file manipulations.
+        - It is recommended to back up the Excel file before running this function to avoid accidental data loss.
+        - The CSV file should have columns that match expected headers like 'Connection', 'Details', 'FailureReason', and 'Status' for correct data mapping.
+    .LINK
+    https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Sync-CISExcelAndCsvData
+#>
+
+function Sync-CISExcelAndCsvData {
+    [OutputType([void])]
+    [CmdletBinding()]
+    param(
+        [string]$ExcelPath,
+        [string]$CsvPath,
+        [string]$SheetName
+    )
+
+    # Import the CSV file
+    $csvData = Import-Csv -Path $CsvPath
+
+    # Get the current date in the specified format
+    $currentDate = Get-Date -Format "yyyy-MM-ddTHH:mm:ss"
+
+    # Load the Excel workbook
+    $excelPackage = Open-ExcelPackage -Path $ExcelPath
+    $worksheet = $excelPackage.Workbook.Worksheets[$SheetName]
+
+    # Define and check new headers, including the date header
+    $lastCol = $worksheet.Dimension.End.Column
+    $newHeaders = @("CSV_Connection", "CSV_Status", "CSV_Date", "CSV_Details", "CSV_FailureReason")
+    $existingHeaders = $worksheet.Cells[1, 1, 1, $lastCol].Value
+
+    # Add new headers if they do not exist
+    foreach ($header in $newHeaders) {
+        if ($header -notin $existingHeaders) {
+            $lastCol++
+            $worksheet.Cells[1, $lastCol].Value = $header
+        }
+    }
+
+    # Save changes made to add headers
+    $excelPackage.Save()
+
+    # Update the worksheet variable to include possible new columns
+    $worksheet = $excelPackage.Workbook.Worksheets[$SheetName]
+
+    # Mapping the headers to their corresponding column numbers
+    $headerMap = @{}
+    for ($col = 1; $col -le $worksheet.Dimension.End.Column; $col++) {
+        $headerMap[$worksheet.Cells[1, $col].Text] = $col
+    }
+
+    # For each record in CSV, find the matching row and update/add data
+    foreach ($row in $csvData) {
+        # Find the matching recommendation # row
+        $matchRow = $null
+        for ($i = 2; $i -le $worksheet.Dimension.End.Row; $i++) {
+            if ($worksheet.Cells[$i, $headerMap['Recommendation #']].Text -eq $row.rec) {
+                $matchRow = $i
+                break
+            }
+        }
+
+        # Update values if a matching row is found
+        if ($matchRow) {
+            foreach ($header in $newHeaders) {
+                if ($header -eq 'CSV_Date') {
+                    $columnIndex = $headerMap[$header]
+                    $worksheet.Cells[$matchRow, $columnIndex].Value = $currentDate
+                } else {
+                    $csvKey = $header -replace 'CSV_', ''
+                    $columnIndex = $headerMap[$header]
+                    $worksheet.Cells[$matchRow, $columnIndex].Value = $row.$csvKey
+                }
+            }
+        }
+    }
+
+    # Save the updated Excel file
+    $excelPackage.Save()
+    $excelPackage.Dispose()
+}

source/en-US/about_M365FoundationsCISReport.help.txt

@@ -1,24 +1,89 @@
-TOPIC
-    about_M365FoundationsCISReport
+TOPIC
+    about_m365foundationscisreport
 
 SHORT DESCRIPTION
-    Automated assessment of 50 CIS 365 Foundations v3.0.0 benchmark.
+    The `M365FoundationsCISReport` module provides cmdlets for auditing and
+    reporting on the security compliance of Microsoft 365 environments based on
+    CIS benchmarks.
 
 LONG DESCRIPTION
-    Automated assessment of 50 CIS 365 Foundations v3.0.0 benchmark.
+    The `M365FoundationsCISReport` module is designed to help administrators
+    ensure that their Microsoft 365 environments adhere to the security best
+    practices outlined by the Center for Internet Security (CIS). The module
+    includes cmdlets for performing comprehensive security audits, generating
+    detailed reports, and synchronizing audit results with CIS benchmark Excel
+    sheets. It aims to streamline the process of maintaining security compliance
+    and improving the overall security posture of Microsoft 365 environments.
+
+Optional Subtopics
+    AUDITING AND REPORTING
+    The module provides cmdlets that allow for the auditing of various security
+    aspects of Microsoft 365 environments, including user MFA status,
+    administrative role licenses, and more. The results can be exported and
+    analyzed to ensure compliance with CIS benchmarks.
+
+    DATA SYNCHRONIZATION
+    The module includes functionality to synchronize audit results with CIS
+    benchmark data stored in Excel sheets. This ensures that the documentation
+    is always up-to-date with the latest audit findings.
 
 EXAMPLES
-    PS C:\> {{ add examples here }}
+    # Example 1: Performing a security audit based on CIS benchmarks
+    $auditResults = Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com"
+    $auditResults = Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -ApprovedCloudStorageProviders "DropBox" -ApprovedFederatedDomains "northwind.com"
+    
+    # Example 2: Exporting a security audit and it's nested tables to zipped CSV files
+    Export-M365SecurityAuditTable -AuditResults $auditResults -ExportPath "C:\temp" -ExportOriginalTests -ExportAllTests
+        # Output Ex: 2024.07.07_14.55.55_M365FoundationsAudit_368B2E2F.zip
+    
+    # Example 3: Retrieving licenses for users in administrative roles
+    Get-AdminRoleUserLicense
+    
+    # Example 4: Getting MFA status of users
+    Get-MFAStatus -UserId "user@domain.com"
+    
+    # Example 5: Removing rows with empty status values from a CSV file
+    Remove-RowsWithEmptyCSVStatus -FilePath "C:\Reports\Report.xlsx" -WorksheetName "Sheet1"
+    
+    # Example 6: Synchronizing CIS benchmark data with audit results
+    Sync-CISExcelAndCsvData -ExcelPath "path\to\excel.xlsx" -CsvPath "path\to\data.csv" -SheetName "Combined Profiles"
+    
+    # Example 7: Granting Microsoft Graph permissions to the auditor
+    Grant-M365SecurityAuditConsent -UserPrincipalNameForConsent 'user@example.com'
+    
+    # Example 8: (PowerShell 7.x Only) Creating a new authentication object for the security audit for app-based authentication.
+    $authParams = New-M365SecurityAuditAuthObject -ClientCertThumbPrint "ABCDEF1234567890ABCDEF1234567890ABCDEF12" `
+                                                                -ClientId "12345678-1234-1234-1234-123456789012" `
+                                                                -TenantId "12345678-1234-1234-1234-123456789012" `
+                                                                -OnMicrosoftUrl "yourcompany.onmicrosoft.com" `
+                                                                -SpAdminUrl "https://yourcompany-admin.sharepoint.com"
+    Invoke-M365SecurityAudit -AuthParams $authParams -TenantAdminUrl "https://yourcompany-admin.sharepoint.com"
 
-NOTE:
-    Thank you to all those who contributed to this module, by writing code, sharing opinions, and provided feedback.
+NOTE
+    Ensure that you have the necessary permissions and administrative roles in
+    your Microsoft 365 environment to run these cmdlets. Proper configuration
+    and setup are required for accurate audit results.
 
-TROUBLESHOOTING NOTE:
-    Look out on the Github repository for issues and new releases.
+TROUBLESHOOTING NOTE
+    If you encounter any issues while using the cmdlets, ensure that your
+    environment meets the module prerequisites. Check for any updates or patches
+    that may address known bugs. For issues related to specific cmdlets, refer
+    to the individual help files for troubleshooting tips.
 
 SEE ALSO
-    - {{ Please add Project URI such as github }}}
+    -
+    CIS Benchmarks
+    -
+    Microsoft 365 Security Documentation
+    -
+    PowerShell Documentation
 
 KEYWORDS
-    {{ Add comma separated keywords here }}
+    - Microsoft 365
+    - Security Audit
+    - CIS Benchmarks
+    - Compliance
+    - MFA
+    - User Licenses
+    - Security Reporting
 

source/helper/TestDefinitions.csv

@@ -1,51 +1,52 @@
-Index,TestFileName,Rec,ELevel,ProfileLevel,IG1,IG2,IG3
-1,Test-AntiPhishingPolicy.ps1,2.1.7,E5,L1,FALSE,FALSE,TRUE
-2,Test-AuditDisabledFalse.ps1,6.1.1,E3,L1,TRUE,TRUE,TRUE
-3,Test-AuditLogSearch.ps1,3.1.1,E3,L1,TRUE,TRUE,TRUE
-4,Test-BlockChannelEmails.ps1,8.1.2,E3,L1,FALSE,FALSE,FALSE
-5,Test-BlockMailForwarding.ps1,6.2.1,E3,L1,FALSE,FALSE,FALSE
-6,Test-BlockSharedMailboxSignIn.ps1,1.2.2,E3,L1,FALSE,FALSE,FALSE
-7,Test-CommonAttachmentFilter.ps1,2.1.2,E3,L1,FALSE,TRUE,TRUE
-8,Test-CustomerLockbox.ps1,1.3.6,E5,L2,FALSE,FALSE,FALSE
-9,Test-DialInBypassLobby.ps1,8.5.4,E3,L1,FALSE,FALSE,FALSE
-10,Test-DisallowInfectedFilesDownload.ps1,7.3.1,E5,L2,TRUE,TRUE,TRUE
-11,Test-EnableDKIM.ps1,2.1.9,E3,L1,FALSE,TRUE,TRUE
-12,Test-ExternalNoControl.ps1,8.5.7,E3,L1,FALSE,FALSE,FALSE
-13,Test-ExternalSharingCalendars.ps1,1.3.3,E3,L2,FALSE,TRUE,TRUE
-14,Test-GlobalAdminsCount.ps1,1.1.3,E3,L1,TRUE,TRUE,TRUE
-15,Test-GuestAccessExpiration.ps1,7.2.9,E3,L1,FALSE,FALSE,FALSE
-16,Test-IdentifyExternalEmail.ps1,6.2.3,E3,L1,FALSE,FALSE,FALSE
-17,Test-LinkSharingRestrictions.ps1,7.2.7,E3,L1,TRUE,TRUE,TRUE
-18,Test-MailboxAuditingE3.ps1,6.1.2,E3,L1,TRUE,TRUE,TRUE
-19,Test-MailboxAuditingE5.ps1,6.1.3,E5,L1,TRUE,TRUE,TRUE
-20,Test-MailTipsEnabled.ps1,6.5.2,E3,L2,FALSE,FALSE,FALSE
-21,Test-ManagedApprovedPublicGroups.ps1,1.2.1,E3,L2,TRUE,TRUE,TRUE
-22,Test-MeetingChatNoAnonymous.ps1,8.5.5,E3,L1,FALSE,FALSE,FALSE
-23,Test-ModernAuthExchangeOnline.ps1,6.5.1,E3,L1,FALSE,TRUE,TRUE
-24,Test-ModernAuthSharePoint.ps1,7.2.1,E3,L1,FALSE,TRUE,TRUE
-25,Test-NoAnonymousMeetingJoin.ps1,8.5.1,E3,L2,FALSE,FALSE,FALSE
-26,Test-NoAnonymousMeetingStart.ps1,8.5.2,E3,L1,FALSE,FALSE,FALSE
-27,Test-NotifyMalwareInternal.ps1,2.1.3,E3,L1,FALSE,TRUE,TRUE
-28,Test-NoWhitelistDomains.ps1,6.2.2,E3,L1,FALSE,FALSE,FALSE
-29,Test-OneDriveContentRestrictions.ps1,7.2.4,E3,L2,TRUE,TRUE,TRUE
-30,Test-OneDriveSyncRestrictions.ps1,7.3.2,E3,L2,FALSE,FALSE,FALSE
-31,Test-OrganizersPresent.ps1,8.5.6,E3,L1,FALSE,FALSE,FALSE
-32,Test-OrgOnlyBypassLobby.ps1,8.5.3,E3,L1,FALSE,FALSE,TRUE
-33,Test-PasswordHashSync.ps1,5.1.8.1,E3,L1,FALSE,TRUE,TRUE
-34,Test-PasswordNeverExpirePolicy.ps1,1.3.1,E3,L1,TRUE,TRUE,TRUE
-35,Test-ReauthWithCode.ps1,7.2.10,E3,L1,FALSE,FALSE,FALSE
-36,Test-ReportSecurityInTeams.ps1,8.6.1,E3,L1,FALSE,FALSE,FALSE
-37,Test-RestrictCustomScripts.ps1,7.3.4,E3,L1,FALSE,FALSE,TRUE
-38,Test-RestrictExternalSharing.ps1,7.2.3,E3,L1,TRUE,TRUE,TRUE
-39,Test-RestrictOutlookAddins.ps1,6.3.1,E3,L2,FALSE,TRUE,TRUE
-40,Test-RestrictStorageProvidersOutlook.ps1,6.5.3,E3,L2,TRUE,TRUE,TRUE
-41,Test-RestrictTenantCreation.ps1,5.1.2.3,E3,L1,FALSE,FALSE,FALSE
-42,Test-SafeAttachmentsPolicy.ps1,2.1.4,E5,L2,FALSE,FALSE,TRUE
-43,Test-SafeAttachmentsTeams.ps1,2.1.5,E5,L2,TRUE,TRUE,TRUE
-44,Test-SafeLinksOfficeApps.ps1,2.1.1,E5,L2,TRUE,TRUE,TRUE
-45,Test-SharePointAADB2B.ps1,7.2.2,E3,L1,FALSE,FALSE,FALSE
-46,Test-SharePointExternalSharingDomains.ps1,7.2.6,E3,L2,TRUE,TRUE,TRUE
-47,Test-SharePointGuestsItemSharing.ps1,7.2.5,E3,L2,TRUE,TRUE,TRUE
-48,Test-SpamPolicyAdminNotify.ps1,2.1.6,E3,L1,FALSE,TRUE,TRUE
-49,Test-TeamsExternalAccess.ps1,8.2.1,E3,L2,FALSE,FALSE,FALSE
-50,Test-TeamsExternalFileSharing.ps1,8.1.1,E3,L2,TRUE,TRUE,TRUE
+Index,TestFileName,Rec,RecDescription,ELevel,ProfileLevel,CISControl,CISDescription,IG1,IG2,IG3,Automated,Connection
+1,Test-AdministrativeAccountCompliance.ps1,1.1.1,Ensure Administrative accounts are separate and cloud-only,E3,L1,5.4,Restrict Administrator Privileges to Dedicated Administrator Accounts,TRUE,TRUE,TRUE,FALSE,Microsoft Graph
+2,Test-GlobalAdminsCount.ps1,1.1.3,Ensure that between two and four global admins are designated,E3,L1,5.1,Establish and Maintain an Inventory of Accounts,TRUE,TRUE,TRUE,TRUE,Microsoft Graph
+3,Test-ManagedApprovedPublicGroups.ps1,1.2.1,Ensure that only organizationally managed/approved public groups exist,E3,L2,3.3,Configure Data Access Control Lists,TRUE,TRUE,TRUE,TRUE,Microsoft Graph
+4,Test-BlockSharedMailboxSignIn.ps1,1.2.2,Ensure sign-in to shared mailboxes is blocked,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,EXO | Microsoft Graph
+5,Test-PasswordNeverExpirePolicy.ps1,1.3.1,Ensure the 'Password expiration policy' is set to 'Set passwords to never expire',E3,L1,5.2,Use Unique Passwords,TRUE,TRUE,TRUE,TRUE,Microsoft Graph
+6,Test-ExternalSharingCalendars.ps1,1.3.3,Ensure 'External sharing' of calendars is not available,E3,L2,4.8,Uninstall or Disable Unnecessary Services on Enterprise Assets and Software,FALSE,TRUE,TRUE,TRUE,EXO
+7,Test-CustomerLockbox.ps1,1.3.6,Ensure the customer lockbox feature is enabled,E5,L2,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,EXO
+8,Test-SafeLinksOfficeApps.ps1,2.1.1,Ensure Safe Links for Office Applications is Enabled,E5,L2,10.1,Deploy and Maintain Anti-Malware Software,TRUE,TRUE,TRUE,TRUE,EXO
+9,Test-CommonAttachmentFilter.ps1,2.1.2,Ensure the Common Attachment Types Filter is enabled,E3,L1,9.6,Block Unnecessary File Types,FALSE,TRUE,TRUE,TRUE,EXO
+10,Test-NotifyMalwareInternal.ps1,2.1.3,Ensure notifications for internal users sending malware is Enabled,E3,L1,17.5,Assign Key Roles and Responsibilities,FALSE,TRUE,TRUE,TRUE,EXO
+11,Test-SafeAttachmentsPolicy.ps1,2.1.4,Ensure Safe Attachments policy is enabled,E5,L2,9.7,Deploy and Maintain Email Server Anti-Malware Protections,FALSE,FALSE,TRUE,TRUE,EXO
+12,Test-SafeAttachmentsTeams.ps1,2.1.5,"Ensure Safe Attachments for SharePoint, OneDrive, and Microsoft Teams is Enabled",E5,L2,"9.7,10.1","Deploy and Maintain Email Server Anti-Malware Protections, Deploy and Maintain Anti-Malware Software",TRUE,TRUE,TRUE,TRUE,EXO
+13,Test-SpamPolicyAdminNotify.ps1,2.1.6,Ensure Exchange Online Spam Policies are set to notify administrators,E3,L1,17.5,Assign Key Roles and Responsibilities,FALSE,TRUE,TRUE,TRUE,EXO
+14,Test-AntiPhishingPolicy.ps1,2.1.7,Ensure that an anti-phishing policy has been created,E5,L1,9.7,Deploy and Maintain Email Server Anti-Malware Protections,FALSE,FALSE,TRUE,TRUE,EXO
+15,Test-EnableDKIM.ps1,2.1.9,Ensure that DKIM is enabled for all Exchange Online Domains,E3,L1,9.5,Implement DMARC,FALSE,TRUE,TRUE,TRUE,EXO
+16,Test-AuditLogSearch.ps1,3.1.1,Ensure Microsoft 365 audit log search is Enabled,E3,L1,8.2,Collect Audit Logs,TRUE,TRUE,TRUE,TRUE,EXO
+17,Test-RestrictTenantCreation.ps1,5.1.2.3,Ensure 'Restrict non-admin users from creating tenants' is set to 'Yes',E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,Microsoft Graph
+18,Test-PasswordHashSync.ps1,5.1.8.1,Ensure password hash sync is enabled for hybrid deployments,E3,L1,6.7,Centralize Access Control,FALSE,TRUE,TRUE,TRUE,Microsoft Graph
+19,Test-AuditDisabledFalse.ps1,6.1.1,Ensure 'AuditDisabled' organizationally is set to 'False',E3,L1,8.2,Collect Audit Logs,TRUE,TRUE,TRUE,TRUE,EXO
+20,Test-MailboxAuditingE3.ps1,6.1.2,Ensure mailbox auditing for Office E3 users is Enabled,E3,L1,8.2,Collect audit logs.,TRUE,TRUE,TRUE,TRUE,EXO | Microsoft Graph
+21,Test-MailboxAuditingE5.ps1,6.1.3,Ensure mailbox auditing for Office E5 users is Enabled,E5,L1,8.2,Collect audit logs.,TRUE,TRUE,TRUE,TRUE,EXO | Microsoft Graph
+22,Test-BlockMailForwarding.ps1,6.2.1,Ensure all forms of mail forwarding are blocked and/or disabled,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,EXO
+23,Test-NoWhitelistDomains.ps1,6.2.2,Ensure mail transport rules do not whitelist specific domains,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,EXO
+24,Test-IdentifyExternalEmail.ps1,6.2.3,Ensure email from external senders is identified,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,EXO
+25,Test-RestrictOutlookAddins.ps1,6.3.1,Ensure users installing Outlook add-ins is not allowed,E3,L2,9.4,Restrict Unnecessary or Unauthorized Browser and Email Client Extensions,FALSE,TRUE,TRUE,TRUE,EXO
+26,Test-ModernAuthExchangeOnline.ps1,6.5.1,Ensure modern authentication for Exchange Online is enabled (Automated),E3,L1,3.1,Encrypt Sensitive Data in Transit,FALSE,TRUE,TRUE,TRUE,EXO
+27,Test-MailTipsEnabled.ps1,6.5.2,Ensure MailTips are enabled for end users,E3,L2,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,EXO
+28,Test-RestrictStorageProvidersOutlook.ps1,6.5.3,Ensure additional storage providers are restricted in Outlook on the web,E3,L2,3.3,Configure Data Access Control Lists,TRUE,TRUE,TRUE,TRUE,EXO
+29,Test-ModernAuthSharePoint.ps1,7.2.1,Modern Authentication for SharePoint Applications,E3,L1,3.1,Encrypt Sensitive Data in Transit,FALSE,TRUE,TRUE,TRUE,SPO
+30,Test-SharePointAADB2B.ps1,7.2.2,Ensure SharePoint and OneDrive integration with Azure AD B2B is enabled,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,SPO
+31,Test-RestrictExternalSharing.ps1,7.2.3,Ensure external content sharing is restricted,E3,L1,3.3,Configure Data Access Control Lists,TRUE,TRUE,TRUE,TRUE,SPO
+32,Test-OneDriveContentRestrictions.ps1,7.2.4,Ensure OneDrive content sharing is restricted,E3,L2,3.3,Configure Data Access Control Lists,TRUE,TRUE,TRUE,TRUE,SPO
+33,Test-SharePointGuestsItemSharing.ps1,7.2.5,Ensure that SharePoint guest users cannot share items they don't own,E3,L2,3.3,Configure Data Access Control Lists,TRUE,TRUE,TRUE,TRUE,SPO
+34,Test-SharePointExternalSharingDomains.ps1,7.2.6,Ensure SharePoint external sharing is managed through domain whitelist/blacklists,E3,L2,3.3,Configure Data Access Control Lists,TRUE,TRUE,TRUE,TRUE,SPO
+35,Test-LinkSharingRestrictions.ps1,7.2.7,Ensure link sharing is restricted in SharePoint and OneDrive,E3,L1,3.3,Configure Data Access Control Lists,TRUE,TRUE,TRUE,TRUE,SPO
+36,Test-GuestAccessExpiration.ps1,7.2.9,Ensure guest access to a site or OneDrive will expire automatically,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,SPO
+37,Test-ReauthWithCode.ps1,7.2.10,Ensure reauthentication with verification code is restricted,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,SPO
+38,Test-DisallowInfectedFilesDownload.ps1,7.3.1,Ensure Office 365 SharePoint infected files are disallowed for download,E5,L2,10.1,Deploy and Maintain Anti-Malware Software,TRUE,TRUE,TRUE,TRUE,SPO
+39,Test-OneDriveSyncRestrictions.ps1,7.3.2,Ensure OneDrive sync is restricted for unmanaged devices,E3,L2,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,SPO
+40,Test-RestrictCustomScripts.ps1,7.3.4,Ensure custom script execution is restricted on site collections,E3,L1,2.7,Allowlist Authorized Scripts,FALSE,FALSE,TRUE,TRUE,SPO
+41,Test-TeamsExternalFileSharing.ps1,8.1.1,Ensure external file sharing in Teams is enabled for only approved cloud storage services,E3,L2,3.3,Configure Data Access Control Lists,TRUE,TRUE,TRUE,TRUE,Microsoft Teams
+42,Test-BlockChannelEmails.ps1,8.1.2,Ensure users can't send emails to a channel email address,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,Microsoft Teams
+43,Test-TeamsExternalAccess.ps1,8.2.1,Ensure 'external access' is restricted in the Teams admin center,E3,L2,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,Microsoft Teams
+44,Test-NoAnonymousMeetingJoin.ps1,8.5.1,Ensure anonymous users can't join a meeting,E3,L2,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,Microsoft Teams
+45,Test-NoAnonymousMeetingStart.ps1,8.5.2,Ensure anonymous users and dial-in callers can't start a meeting,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,Microsoft Teams
+46,Test-OrgOnlyBypassLobby.ps1,8.5.3,Ensure only people in my org can bypass the lobby,E3,L1,6.8,Define and Maintain Role-Based Access Control,FALSE,FALSE,TRUE,TRUE,Microsoft Teams
+47,Test-DialInBypassLobby.ps1,8.5.4,Ensure users dialing in can't bypass the lobby,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,Microsoft Teams
+48,Test-MeetingChatNoAnonymous.ps1,8.5.5,Ensure meeting chat does not allow anonymous users,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,Microsoft Teams
+49,Test-OrganizersPresent.ps1,8.5.6,Ensure only organizers and co-organizers can present,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,Microsoft Teams
+50,Test-ExternalNoControl.ps1,8.5.7,Ensure external participants can't give or request control,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,Microsoft Teams
+51,Test-ReportSecurityInTeams.ps1,8.6.1,Ensure users can report security concerns in Teams,E3,L1,0,Explicitly Not Mapped,FALSE,FALSE,FALSE,TRUE,Microsoft Teams | EXO

source/tests/Test-AdministrativeAccountCompliance.ps1

@@ -0,0 +1,100 @@
+function Test-AdministrativeAccountCompliance {
+    [CmdletBinding()]
+    param ()
+    begin {
+        # The following conditions are checked:
+        # Condition A: The administrative account is cloud-only (not synced).
+        # Condition B: The account is assigned a valid license (e.g., Microsoft Entra ID P1 or P2).
+        # Condition C: The administrative account does not have any other application assignments (only valid licenses).
+        $validLicenses = @('AAD_PREMIUM', 'AAD_PREMIUM_P2')
+        $recnum = "1.1.1"
+        Write-Verbose "Starting Test-AdministrativeAccountCompliance with Rec: $recnum"
+    }
+    process {
+        try {
+            # Retrieve admin roles, assignments, and user details including licenses
+            Write-Verbose "Retrieving admin roles, assignments, and user details including licenses"
+            $adminRoleAssignments = Get-CISMgOutput -Rec $recnum
+            $adminRoleUsers = @()
+            foreach ($roleName in $adminRoleAssignments.Keys) {
+                $assignments = $adminRoleAssignments[$roleName]
+                foreach ($assignment in $assignments) {
+                    $userDetails = $assignment.UserDetails
+                    $userId = $userDetails.Id
+                    $userPrincipalName = $userDetails.UserPrincipalName
+                    $licenses = $assignment.Licenses
+                    $licenseString = if ($licenses) { ($licenses.SkuPartNumber -join '|') } else { "No Licenses Found" }
+                    # Condition A: Check if the account is cloud-only
+                    $cloudOnlyStatus = if ($userDetails.OnPremisesSyncEnabled) { "Fail" } else { "Pass" }
+                    # Condition B: Check if the account has valid licenses
+                    $hasValidLicense = $licenses.SkuPartNumber | ForEach-Object { $validLicenses -contains $_ }
+                    $validLicensesStatus = if ($hasValidLicense) { "Pass" } else { "Fail" }
+                    # Condition C: Check if the account has no other licenses
+                    $hasInvalidLicense = $licenses.SkuPartNumber | ForEach-Object { $validLicenses -notcontains $_ }
+                    $invalidLicenses = $licenses.SkuPartNumber | Where-Object { $validLicenses -notcontains $_ }
+                    $applicationAssignmentStatus = if ($hasInvalidLicense) { "Fail" } else { "Pass" }
+                    Write-Verbose "User: $userPrincipalName, Cloud-Only: $cloudOnlyStatus, Valid Licenses: $validLicensesStatus, Invalid Licenses: $($invalidLicenses -join ', ')"
+                    # Collect user information
+                    $adminRoleUsers += [PSCustomObject]@{
+                        UserName                    = $userPrincipalName
+                        RoleName                    = $roleName
+                        UserId                      = $userId
+                        HybridUser                  = $userDetails.OnPremisesSyncEnabled
+                        Licenses                    = $licenseString
+                        CloudOnlyStatus             = $cloudOnlyStatus
+                        ValidLicensesStatus         = $validLicensesStatus
+                        ApplicationAssignmentStatus = $applicationAssignmentStatus
+                    }
+                }
+            }
+            # Group admin role users by UserName and collect unique roles and licenses
+            Write-Verbose "Grouping admin role users by UserName"
+            $uniqueAdminRoleUsers = $adminRoleUsers | Group-Object -Property UserName | ForEach-Object {
+                $first = $_.Group | Select-Object -First 1
+                $roles = ($_.Group.RoleName -join ', ')
+                $licenses = (($_.Group | Select-Object -ExpandProperty Licenses) -join ',').Split(',') | Select-Object -Unique
+                $first | Select-Object UserName, UserId, HybridUser, @{Name = 'Roles'; Expression = { $roles } }, @{Name = 'Licenses'; Expression = { $licenses -join '|' } }, CloudOnlyStatus, ValidLicensesStatus, ApplicationAssignmentStatus
+            }
+            # Identify non-compliant users based on conditions A, B, and C
+            Write-Verbose "Identifying non-compliant users based on conditions"
+            $nonCompliantUsers = $uniqueAdminRoleUsers | Where-Object {
+                $_.HybridUser -or # Fails Condition A
+                $_.ValidLicensesStatus -eq "Fail" -or # Fails Condition B
+                $_.ApplicationAssignmentStatus -eq "Fail" # Fails Condition C
+            }
+            # Generate failure reasons
+            Write-Verbose "Generating failure reasons for non-compliant users"
+            $failureReasons = $nonCompliantUsers | ForEach-Object {
+                "$($_.UserName)|$($_.Roles)|$($_.CloudOnlyStatus)|$($_.ValidLicensesStatus)|$($_.ApplicationAssignmentStatus)"
+            }
+            $failureReasons = $failureReasons -join "`n"
+            $failureReason = if ($nonCompliantUsers) {
+                "Non-Compliant Accounts: $($nonCompliantUsers.Count)"
+            }
+            else {
+                "Compliant Accounts: $($uniqueAdminRoleUsers.Count)"
+            }
+            $result = $nonCompliantUsers.Count -eq 0
+            $status = if ($result) { 'Pass' } else { 'Fail' }
+            $details = if ($nonCompliantUsers) { "Username | Roles | Cloud-Only Status | EntraID P1/P2 License Status | Other Applications Assigned Status`n$failureReasons" } else { "N/A" }
+            Write-Verbose "Assessment completed. Result: $status"
+            # Create the parameter splat
+            $params = @{
+                Rec           = $recnum
+                Result        = $result
+                Status        = $status
+                Details       = $details
+                FailureReason = $failureReason
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
+    }
+    end {
+        # Output the result
+        return $auditResult
+    }
+}

source/tests/Test-AntiPhishingPolicy.ps1

@@ -1,59 +1,227 @@
 function Test-AntiPhishingPolicy {
     [CmdletBinding()]
-    param (
-        # Parameters can be added if needed
-    )
-
+    [OutputType([CISAuditResult])]
+    param ()
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        $recnum = "2.1.7"
+        Write-Verbose "Running Test-AntiPhishingPolicy for $recnum..."
+        #. .\source\Classes\CISAuditResult.ps1
+        <#
+        Conditions for 2.1.7 (L1) Ensure robust anti-phishing policies are enforced
+        Validate test for a pass:
+        - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        - Ensure the policies are checked in the following order of precedence: Strict, Standard, Custom, and Default.
+            - Specific conditions to check:
+                - Condition A: At least one policy (preferably Strict or Standard) should cover all users or be marked as default.
+                - Condition B: The policy must have enabled settings including PhishThresholdLevel at least 2, EnableMailboxIntelligenceProtection, EnableMailboxIntelligence, and EnableSpoofIntelligence.
+        Validate test for a fail:
+        - Identify any policy misconfigurations or absence of comprehensive coverage.
+            - Specific conditions to check:
+                - Condition A: No policy comprehensively covers all users or meets specified security criteria.
+                - Condition B: Critical security features like Spoof Intelligence or Mailbox Intelligence are disabled in the relevant policies.
+        #>
     }
-
     process {
-
-        # Retrieve and validate the anti-phishing policies
-        $antiPhishPolicies = Get-AntiPhishPolicy
-        $validatedPolicies = $antiPhishPolicies | Where-Object {
-            $_.Enabled -eq $true -and
-            $_.PhishThresholdLevel -ge 2 -and
-            $_.EnableMailboxIntelligenceProtection -eq $true -and
-            $_.EnableMailboxIntelligence -eq $true -and
-            $_.EnableSpoofIntelligence -eq $true
+        try {
+            # Step 1: Retrieve all anti-phishing policies
+            #$VerbosePreference = "Continue"
+            Write-Verbose "Retrieving all anti-phishing policies..."
+            $antiPhishPolicies = Get-CISExoOutput -Rec $recnum
+            # Step 2: Initialize variables to track compliance and details
+            $compliantPolicy = $null
+            $details = @()
+            $failureReasons = @()
+            $hasFullCoveragePolicy = $false
+            $policiesEvaluated = @()
+            $PassedTests = @()
+            $FailedTests = @()
+            Write-Verbose "Evaluating each policy for compliance..."
+            # Separate policies based on type
+            $strictPolicy = $antiPhishPolicies | Where-Object { $_.Identity -match "Strict Preset Security Policy" }
+            $standardPolicy = $antiPhishPolicies | Where-Object { $_.Identity -match "Standard Preset Security Policy" }
+            $customPolicies = $antiPhishPolicies | Where-Object { -not ($_.Identity -match "Strict Preset Security Policy" -or $_.Identity -match "Standard Preset Security Policy" -or $_.IsDefault) }
+            $defaultPolicy = $antiPhishPolicies | Where-Object { $_.IsDefault }
+            # Step 3: Check for Strict Preset Security Policy
+            if ($null -ne $strictPolicy) {
+                Write-Verbose "Evaluating policy: $($strictPolicy.Identity)"
+                $policiesEvaluated += $strictPolicy.Identity
+                # Check if policy is compliant
+                $isCompliant = Test-PhishPolicyCompliance -policy $strictPolicy
+                # Log failure reasons for non-compliant policies
+                if (-not $isCompliant) {
+                    $failureReasons += "Policy $($strictPolicy.Identity) does not meet compliance criteria."
+                    Write-Verbose "Policy $($strictPolicy.Identity) fails to meet one or more required conditions."
+                    $FailedTests += $strictPolicy.Identity
+                }
+                # Compile details of each policy using the new function
+                $details += Get-PhishPolicyDetail -policy $strictPolicy -isCompliant $isCompliant
+                # Check if policy is Strict and covers all users
+                if ($isCompliant) {
+                    $PassedTests += $strictPolicy.Identity
+                    Write-Verbose "Policy $($strictPolicy.Identity) is compliant."
+                    $strictUsersToProtect = $strictPolicy.TargetedUsersToProtect
+                    if ($strictUsersToProtect.count -eq 0) {
+                        $hasFullCoveragePolicy = $true
+                        $compliantPolicy = $strictPolicy
+                        $details += "Is Full Coverage Policy: $hasFullCoveragePolicy`n`n"
+                        Write-Verbose "$($strictPolicy.Identity) is compliant and covers all users. Stopping further evaluation."
+                    }
+                    else {
+                        $details += "Is Full Coverage Policy: $($false)`n`n"
+                    }
+                }
+            }
+            # Step 4: Check for Standard Preset Security Policy if no full coverage from Strict
+            if ($null -ne $standardPolicy -and $hasFullCoveragePolicy -ne $true) {
+                Write-Verbose "Evaluating policy: $($standardPolicy.Identity)"
+                $policiesEvaluated += $standardPolicy.Identity
+                # Check if policy is compliant
+                $isCompliant = Test-PhishPolicyCompliance -policy $standardPolicy
+                # Log failure reasons for non-compliant policies
+                if (-not $isCompliant) {
+                    $failureReasons += "$($standardPolicy.Identity) does not meet compliance criteria."
+                    Write-Verbose "$($standardPolicy.Identity) fails to meet one or more required conditions."
+                    $FailedTests += $standardPolicy.Identity
+                }
+                # Compile details of each policy using the new function
+                $details += Get-PhishPolicyDetail -policy $standardPolicy -isCompliant $isCompliant
+                # Check if policy is Strict and covers all users
+                if ($isCompliant) {
+                    Write-Verbose "$($standardPolicy.Identity) is compliant."
+                    $PassedTests += $standardPolicy.Identity
+                    $standardUsersToProtect = $standardPolicy.TargetedUsersToProtect
+                    if ($standardUsersToProtect.count -eq 0) {
+                        $hasFullCoveragePolicy = $true
+                        $compliantPolicy = $standardPolicy
+                        $details += "Is Full Coverage Policy: $hasFullCoveragePolicy`n`n"
+                        Write-Verbose "$($standardPolicy.Identity) is compliant and covers all users. Stopping further evaluation."
+                    }
+                    else {
+                        $details += "Is Full Coverage Policy: $($false)`n`n"
+                    }
+                }
+            }
+            elseif ($null -ne $standardPolicy) {
+                Write-Verbose "$($standardPolicy.Identity) was not evaluated."
+                $isCompliant = Test-PhishPolicyCompliance -policy $standardPolicy
+                $details += Get-PhishPolicyDetail -policy $standardPolicy -isCompliant $isCompliant
+                $details += "Is Full Coverage Policy: $($false)`n`n"
+            }
+            # Step 5: Check Custom Policies if no full coverage from Strict or Standard
+            if ($null -ne $customPolicies -and $hasFullCoveragePolicy -ne $true) {
+                foreach ($policy in $customPolicies) {
+                    if (-not $compliantPolicy) {
+                        Write-Verbose "Evaluating policy: $($policy.Identity)"
+                        $policiesEvaluated += $policy.Identity
+                        # Check if policy is compliant
+                        $isCompliant = Test-PhishPolicyCompliance -policy $policy
+                        # Log failure reasons for non-compliant policies
+                        if (-not $isCompliant) {
+                            $failureReasons += "$($policy.Identity) Policy does not meet compliance criteria."
+                            Write-Verbose "$($policy.Identity) Policy fails to meet one or more required conditions."
+                            $FailedTests += $policy.Identity
+                        }
+                        # Compile details of each policy using the new function
+                        $details += Get-PhishPolicyDetail -policy $policy -isCompliant $isCompliant
+                        # Check if policy is Custom and covers all users
+                        if ($isCompliant) {
+                            Write-Verbose "$($policy.Identity) is compliant."
+                            $PassedTests += $policy.Identity
+                            $custompolicyUsersToProtect = $policy.TargetedUsersToProtect
+                            if ($custompolicyUsersToProtect.count -eq 0) {
+                                $hasFullCoveragePolicy = $true
+                                $compliantPolicy = $policy
+                                $details += "Is Full Coverage Policy: $hasFullCoveragePolicy`n"
+                                Write-Verbose "$($policy.Identity) is compliant and covers all users. Stopping further evaluation."
+                            }
+                            else {
+                                $details += "Is Full Coverage Policy: $($false)`n`n"
+                            }
+                        }
+                    }
+                    elseif ($compliantPolicy) {
+                        Write-Verbose "$($policy.Identity) was not evaluated."
+                        $isCompliant = Test-PhishPolicyCompliance -policy $policy
+                        $details += Get-PhishPolicyDetail -policy $policy -isCompliant $isCompliant
+                        $details += "Is Full Coverage Policy: $($false)`n`n"
+                    }
+                }
+            }
+            elseif ($null -ne $customPolicies ) {
+                foreach ($policy in $customPolicies) {
+                    Write-Verbose "$($policy.Identity) was not evaluated."
+                    $isCompliant = Test-PhishPolicyCompliance -policy $policy
+                    $details += Get-PhishPolicyDetail -policy $policy -isCompliant $isCompliant
+                    $details += "Is Full Coverage Policy: $($false)`n`n"
+                }
+            }
+            # Step 6: Check Default Policy if no full coverage from Strict, Standard, or Custom
+            if ($null -ne $defaultPolicy -and $hasFullCoveragePolicy -ne $true) {
+                Write-Verbose "Evaluating policy: $($defaultPolicy.Identity)"
+                $policiesEvaluated += $defaultPolicy.Identity
+                # Check if policy is compliant
+                $isCompliant = Test-PhishPolicyCompliance -policy $defaultPolicy
+                # Log failure reasons for non-compliant policies
+                if (-not $isCompliant) {
+                    $failureReasons += "$($defaultPolicy.Identity) Policy does not meet compliance criteria."
+                    Write-Verbose "$($defaultPolicy.Identity) Policy fails to meet one or more required conditions."
+                    $FailedTests += $defaultPolicy.Identity
+                }
+                # Compile details of each policy using the new function
+                $details += Get-PhishPolicyDetail -policy $defaultPolicy -isCompliant $isCompliant
+                # Check if policy is Default and covers all users
+                if ($isCompliant) {
+                    Write-Verbose "$($defaultPolicy.Identity) is compliant."
+                    $PassedTests += $defaultPolicy.Identity
+                    $defaultUsersToProtect = $defaultPolicy.TargetedUsersToProtect
+                    if ($defaultUsersToProtect.count -eq 0) {
+                        $hasFullCoveragePolicy = $true
+                        $compliantPolicy = $defaultPolicy
+                        $details += "Is Full Coverage Policy: $hasFullCoveragePolicy`n"
+                        Write-Verbose "$($defaultPolicy.Identity) is compliant and covers all users. Stopping further evaluation."
+                    }
+                    else {
+                        $details += "Is Full Coverage Policy: $($false)`n`n"
+                    }
+                }
+            }
+            elseif ($null -ne $defaultPolicy) {
+                Write-Verbose "$($defaultPolicy.Identity) was not evaluated."
+                $isCompliant = Test-PhishPolicyCompliance -policy $defaultPolicy
+                $details += Get-PhishPolicyDetail -policy $defaultPolicy -isCompliant $isCompliant
+                $details += "Is Full Coverage Policy: $($false)`n`n"
+            }
+            # Determine overall compliance based on the evaluations
+            $isOverallCompliant = $hasFullCoveragePolicy -and $null -ne $compliantPolicy
+            # Prepare result details
+            $resultDetails = if ($isOverallCompliant) {
+                "Compliant Policy: $($compliantPolicy.Identity)`nDetails:`n" + ($details -join "`n")
+            }
+            else {
+                "Non-Compliant or No Policy Fully Covers All Users.`nDetails:`n" + ($details -join "`n")
+            }
+            # Verbose output for the overall compliance
+            Write-Verbose "Overall Compliance: $isOverallCompliant"
+            #$VerbosePreference = "SilentlyContinue"
+            # Prepare the parameters for the audit result
+            $params = @{
+                Rec           = $recnum
+                Result        = $isOverallCompliant
+                Status        = if ($isOverallCompliant) { "Pass" } else { "Fail" }
+                Details       = $resultDetails
+                FailureReason = if (-not $isOverallCompliant) { $failureReasons -join "`n" } else { "None: All settings are correct based on the highest precedence policy that applies to all users." }
+            }
+            # Initialize the audit result
+            $auditResult = Initialize-CISAuditResult @params
         }
-
-        # Check if there is at least one policy that meets the requirements
-        $isCompliant = $validatedPolicies.Count -gt 0
-
-        # Prepare failure details if policies are not compliant
-        $failureDetails = if (-not $isCompliant) {
-            "No anti-phishing policy is fully compliant with CIS benchmark requirements."
-        } else {
-            "Compliant Anti-Phish Policy Names: " + ($validatedPolicies.Name -join ', ')
+        catch {
+            Write-Error "An error occurred during the test $recnum`:: $_"
+            $auditResult = Get-TestError -LastError $_ -recnum $recnum
         }
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.Status = if ($isCompliant) { "Pass" } else { "Fail" }
-        $auditResult.ELevel = "E5"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.Rec = "2.1.7"
-        $auditResult.RecDescription = "Ensure that an anti-phishing policy has been created"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "9.7"
-        $auditResult.CISDescription = "Deploy and Maintain Email Server Anti-Malware Protections"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $false
-        $auditResult.IG3 = $true
-        $auditResult.Result = $isCompliant
-        $auditResult.Details = $failureDetails
-        $auditResult.FailureReason = if (-not $isCompliant) { "Anti-phishing policies do not meet CIS benchmark requirements." } else { "N/A" }
-
-        $auditResults += $auditResult
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        return $auditResult
     }
 }
+
+

source/tests/Test-AuditDisabledFalse.ps1

@@ -1,43 +1,67 @@
 function Test-AuditDisabledFalse {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
+    # Aligned
     param (
         # Parameters can be added if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Conditions for 6.1.1 (L1) Ensure 'AuditDisabled' organizationally is set to 'False'
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: The `AuditDisabled` organizational setting is set to `False` in the Microsoft 365 admin center.
+        #   - Condition B: Using PowerShell, the `AuditDisabled` property in the organization's configuration is set to `False`.
+        #   - Condition C: Ensure mailbox auditing is enabled by default at the organizational level.
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: The `AuditDisabled` organizational setting is set to `True` in the Microsoft 365 admin center.
+        #   - Condition B: Using PowerShell, the `AuditDisabled` property in the organization's configuration is set to `True`.
+        #   - Condition C: Mailbox auditing is not enabled by default at the organizational level.
+        # Initialization code, if needed
+        $recnum = "6.1.1"
+        Write-Verbose "Running Test-AuditDisabledFalse for $recnum..."
     }
-
     process {
-        # 6.1.1 (L1) Ensure 'AuditDisabled' organizationally is set to 'False'
-        # Pass if AuditDisabled is False. Fail otherwise.
-        $auditDisabledConfig = Get-OrganizationConfig | Select-Object AuditDisabled
-        $auditNotDisabled = -not $auditDisabledConfig.AuditDisabled
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.Status = if ($auditNotDisabled) { "Pass" } else { "Fail" }
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.Rec = "6.1.1"
-        $auditResult.RecDescription = "Ensure 'AuditDisabled' organizationally is set to 'False'"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "8.2"
-        $auditResult.CISDescription = "Collect Audit Logs"
-        $auditResult.IG1 = $true
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-        $auditResult.Result = $auditNotDisabled
-        $auditResult.Details = if ($auditNotDisabled) { "Audit is not disabled organizationally" } else { "Audit is disabled organizationally" }
-        $auditResult.FailureReason = if (-not $auditNotDisabled) { "AuditDisabled is set to True" } else { "N/A" }
-
-        $auditResults += $auditResult
+        try {
+            # 6.1.1 (L1) Ensure 'AuditDisabled' organizationally is set to 'False'
+            # Retrieve the AuditDisabled configuration (Condition B)
+            $auditNotDisabled = Get-CISExoOutput -Rec $recnum
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $auditNotDisabled) {
+                "AuditDisabled is set to True"  # Condition A Fail
+            }
+            else {
+                "N/A"
+            }
+            $details = if ($auditNotDisabled) {
+                "Audit is not disabled organizationally"  # Condition C Pass
+            }
+            else {
+                "Audit is disabled organizationally"  # Condition C Fail
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $auditNotDisabled
+                Status        = if ($auditNotDisabled) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-AuditLogSearch.ps1

@@ -1,43 +1,68 @@
 function Test-AuditLogSearch {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be added if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "3.1.1"
+        Write-Verbose "Running Test-AuditLogSearch for $recnum..."
+        <#
+        Conditions for 3.1.1 (L1) Ensure Microsoft 365 audit log search is Enabled
+        Validate test for a pass:
+        - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        - Specific conditions to check:
+            - Condition A: Audit log search is enabled in the Microsoft Purview compliance portal.
+            - Condition B: The audit log retains user and admin activity for 90 days.
+            - Condition C: Audit log search capabilities are functional (search results are displayed for activities within the past 30 days).
+        Validate test for a fail:
+        - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        - Specific conditions to check:
+            - Condition A: Audit log search is not enabled in the Microsoft Purview compliance portal.
+            - Condition B: The audit log does not retain user and admin activity for 90 days.
+            - Condition C: Audit log search capabilities are non-functional (no search results are displayed for activities within the past 30 days).
+        #>
     }
-
     process {
-        # 3.1.1 (L1) Ensure Microsoft 365 audit log search is Enabled
-        # Pass if UnifiedAuditLogIngestionEnabled is True. Fail otherwise.
-        $auditLogConfig = Get-AdminAuditLogConfig | Select-Object UnifiedAuditLogIngestionEnabled
-        $auditLogResult = $auditLogConfig.UnifiedAuditLogIngestionEnabled
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.Status = if ($auditLogResult) { "Pass" } else { "Fail" }
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.Rec = "3.1.1"
-        $auditResult.RecDescription = "Ensure Microsoft 365 audit log search is Enabled"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "8.2"
-        $auditResult.CISDescription = "Collect Audit Logs"
-        $auditResult.IG1 = $true
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-        $auditResult.Result = $auditLogResult
-        $auditResult.Details = "UnifiedAuditLogIngestionEnabled: $($auditLogConfig.UnifiedAuditLogIngestionEnabled)"
-        $auditResult.FailureReason = if (-not $auditLogResult) { "Audit log search is not enabled" } else { "N/A" }
-
-        $auditResults += $auditResult
+        try {
+            # 3.1.1 (L1) Ensure Microsoft 365 audit log search is Enabled
+            $auditLogResult = Get-CISExoOutput -Rec $recnum
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $auditLogResult) {
+                # Condition A (Fail): Audit log search is not enabled in the Microsoft Purview compliance portal
+                "Audit log search is not enabled"
+            }
+            else {
+                "N/A"
+            }
+            $details = if ($auditLogResult) {
+                # Condition A (Pass): Audit log search is enabled in the Microsoft Purview compliance portal
+                "UnifiedAuditLogIngestionEnabled: True"
+            }
+            else {
+                "UnifiedAuditLogIngestionEnabled: False"
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $auditLogResult
+                Status        = if ($auditLogResult) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
-}
+}

source/tests/Test-BlockChannelEmails.ps1

@@ -1,44 +1,67 @@
 function Test-BlockChannelEmails {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be added here if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "8.1.2"
+        Write-Verbose "Running Test-BlockChannelEmails for $recnum..."
     }
-
     process {
-        # 8.1.2 (L1) Ensure users can't send emails to a channel email address
-        # Connect to Teams PowerShell using Connect-MicrosoftTeams
-
-        $teamsClientConfig = Get-CsTeamsClientConfiguration -Identity Global
-        $allowEmailIntoChannel = $teamsClientConfig.AllowEmailIntoChannel
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "0.0" # This control is Explicitly Not Mapped as per the image provided
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-        $auditResult.Rec = "8.1.2"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $false # Set based on the benchmark
-        $auditResult.IG2 = $false # Set based on the benchmark
-        $auditResult.IG3 = $false # Set based on the benchmark
-        $auditResult.RecDescription = "Ensure users can't send emails to a channel email address"
-        $auditResult.Result = -not $allowEmailIntoChannel
-        $auditResult.Details = "AllowEmailIntoChannel is set to $allowEmailIntoChannel"
-        $auditResult.FailureReason = if ($allowEmailIntoChannel) { "Emails can be sent to a channel email address" } else { "N/A" }
-        $auditResult.Status = if (-not $allowEmailIntoChannel) { "Pass" } else { "Fail" }
-
-        $auditResults += $auditResult
+        try {
+            # 8.1.2 (L1) Ensure users can't send emails to a channel email address
+            #
+            # Validate test for a pass:
+            # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            # - Specific conditions to check:
+            #   - Condition A: The `AllowEmailIntoChannel` setting in Teams is set to `False`.
+            #   - Condition B: The setting `Users can send emails to a channel email address` is set to `Off` in the Teams admin center.
+            #   - Condition C: Verification using PowerShell confirms that the `AllowEmailIntoChannel` setting is disabled.
+            #
+            # Validate test for a fail:
+            # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            # - Specific conditions to check:
+            #   - Condition A: The `AllowEmailIntoChannel` setting in Teams is not set to `False`.
+            #   - Condition B: The setting `Users can send emails to a channel email address` is not set to `Off` in the Teams admin center.
+            #   - Condition C: Verification using PowerShell indicates that the `AllowEmailIntoChannel` setting is enabled.
+            # Retrieve Teams client configuration
+            $teamsClientConfig = Get-CISMSTeamsOutput -Rec $recnum
+            $allowEmailIntoChannel = $teamsClientConfig.AllowEmailIntoChannel
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if ($allowEmailIntoChannel) {
+                "Emails can be sent to a channel email address" # Condition A Fail: AllowEmailIntoChannel is True
+            }
+            else {
+                "N/A" # Condition A Pass: AllowEmailIntoChannel is False
+            }
+            $details = if ($allowEmailIntoChannel) {
+                "AllowEmailIntoChannel is set to True" # Condition B Fail: Emails are allowed
+            }
+            else {
+                "AllowEmailIntoChannel is set to False" # Condition B Pass: Emails are blocked
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec            = $recnum
+                Result         = -not $allowEmailIntoChannel
+                Status         = if (-not $allowEmailIntoChannel) { "Pass" } else { "Fail" }
+                Details        = $details
+                FailureReason  = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-BlockMailForwarding.ps1

@@ -1,51 +1,87 @@
 function Test-BlockMailForwarding {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
         # Parameters can be added if needed
     )
-
     begin {
-
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.Rec = "6.2.1"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "0.0"
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $false
-        $auditResult.IG3 = $false
-        $auditResult.RecDescription = "Ensure all forms of mail forwarding are blocked and/or disabled"
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "6.2.1"
+        Write-Verbose "Running Test-BlockMailForwarding for $recnum..."
+        <#
+        Conditions for 6.2.1 (L1) Ensure all forms of mail forwarding are blocked and/or disabled
+        Validate test for a pass:
+        - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        - Specific conditions to check:
+          - Condition A: Transport rules do not forward email to external domains.
+          - Condition B: Anti-spam outbound policy is configured to disable automatic email forwarding to external domains.
+          - Condition C: No exceptions to the forwarding rules unless explicitly defined by organizational policy.
+        Validate test for a fail:
+        - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        - Specific conditions to check:
+          - Condition A: One or more transport rules forward email to external domains.
+          - Condition B: Anti-spam outbound policy does not disable automatic email forwarding to external domains.
+          - Condition C: Unapproved exceptions to the forwarding rules are present.
+        #>
     }
-
     process {
-        # Verify that no rules are forwarding the email to external domains
-        $transportRules = Get-TransportRule | Where-Object { $_.RedirectMessageTo -ne $null }
-        $forwardingBlocked = $transportRules.Count -eq 0
-
-        $auditResult.Result = $forwardingBlocked
-        $auditResult.Details = if ($transportRules.Count -gt 0) {
-            $transportRules | ForEach-Object {
-                "$($_.Name) redirects to $($_.RedirectMessageTo)"
-            } -join " | "
-        } else {
-            "Step 1: No forwarding rules found. Please proceed with Step 2 described in CIS Benchmark."
+        try {
+            # 6.2.1 (L1) Ensure all forms of mail forwarding are blocked and/or disabled
+            # Step 1: Retrieve the transport rules that redirect messages
+            $transportRules,$nonCompliantSpamPolicies = Get-CISExoOutput -Rec $recnum
+            $transportForwardingBlocked = $transportRules.Count -eq 0
+            # Step 2: Check all anti-spam outbound policies
+            $nonCompliantSpamPoliciesArray = @($nonCompliantSpamPolicies)
+            $spamForwardingBlocked = $nonCompliantSpamPoliciesArray.Count -eq 0
+            # Determine overall compliance
+            $forwardingBlocked = $transportForwardingBlocked -and $spamForwardingBlocked
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = @()
+            $details = @()
+            if ($transportRules -ne 1) {
+                # Fail Condition A
+                $failureReasons += "Mail forwarding rules found: $($transportRules.Name -join ', ')"
+                $details += "Transport Rules Details:`nRule Name|Redirects To"
+                $details += $transportRules | ForEach-Object {
+                    "$($_.Name)|$($_.RedirectMessageTo -join ', ')"
+                }
+                $details += "`n"
+            }
+            if ($nonCompliantSpamPoliciesArray.Count -gt 0) {
+                # Fail Condition B
+                $failureReasons += "Outbound spam policies allowing automatic forwarding found."
+                $details += "Policy|AutoForwardingMode"
+                $details += $nonCompliantSpamPoliciesArray | ForEach-Object {
+                    "$($_.Name)|$($_.AutoForwardingMode)"
+                }
+            }
+            if ($failureReasons.Count -eq 0) {
+                $failureReasons = "N/A"
+                $details = "Both transport rules and outbound spam policies are configured correctly to block forwarding."
+            }
+            else {
+                $failureReasons = $failureReasons -join " | "
+                $details = $details -join "`n"
+            }
+            # Populate the audit result
+            $params = @{
+                Rec           = $recnum
+                Result        = $forwardingBlocked
+                Status        = if ($forwardingBlocked) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
         }
-        $auditResult.FailureReason = if (-not $forwardingBlocked) {
-            "Mail forwarding rules found: $($transportRules.Name -join ', ')"
-        } else {
-            "N/A"
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
-        $auditResult.Status = if ($forwardingBlocked) { "Pass" } else { "Fail" }
     }
-
     end {
-        # Return the result object
+        # Return the audit result
         return $auditResult
     }
-}
-
-
-
-
+}

source/tests/Test-BlockSharedMailboxSignIn.ps1

@@ -1,47 +1,100 @@
 function Test-BlockSharedMailboxSignIn {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
         # Parameters can be added if needed
     )
 
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "1.2.2"
+        Write-Verbose "Running Test-BlockSharedMailboxSignIn for $recnum..."
+        # Conditions for 1.2.2 (L1) Ensure sign-in to shared mailboxes is blocked
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: No shared mailboxes have the "Sign-in blocked" option disabled in the properties pane on the Microsoft 365 admin center.
+        #   - Condition B: Using PowerShell, the `AccountEnabled` property for all shared mailboxes is set to `False`.
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: One or more shared mailboxes have the "Sign-in blocked" option enabled in the properties pane on the Microsoft 365 admin center.
+        #   - Condition B: Using PowerShell, the `AccountEnabled` property for one or more shared mailboxes is set to `True`.
     }
-
     process {
-        # 1.2.2 (L1) Ensure sign-in to shared mailboxes is blocked
-        # Pass if all shared mailboxes have AccountEnabled set to False.
-        # Fail if any shared mailbox has AccountEnabled set to True.
-
-        $MBX = Get-EXOMailbox -RecipientTypeDetails SharedMailbox
-        $sharedMailboxDetails = $MBX | ForEach-Object { Get-AzureADUser -ObjectId $_.ExternalDirectoryObjectId }
-        $enabledMailboxes = $sharedMailboxDetails | Where-Object { $_.AccountEnabled } | ForEach-Object { $_.DisplayName }
-        $allBlocked = $enabledMailboxes.Count -eq 0
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "0.0" # Control is explicitly not mapped
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-        $auditResult.Rec = "1.2.2"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $false # Control is not mapped, hence IG1 is false
-        $auditResult.IG2 = $false # Control is not mapped, hence IG2 is false
-        $auditResult.IG3 = $false # Control is not mapped, hence IG3 is false
-        $auditResult.RecDescription = "Ensure sign-in to shared mailboxes is blocked"
-        $auditResult.Result = $allBlocked
-        $auditResult.Details = "Enabled Mailboxes: $($enabledMailboxes -join ', ')"
-        $auditResult.FailureReason = if ($allBlocked) { "N/A" } else { "Some mailboxes have sign-in enabled: $($enabledMailboxes -join ', ')" }
-        $auditResult.Status = if ($allBlocked) { "Pass" } else { "Fail" }
-
-        $auditResults += $auditResult
+        try {
+            # Step: Retrieve shared mailbox details
+            # $objectids Mock Object
+            <#
+                $objectids = @(
+                    "123e4567-e89b-12d3-a456-426614174000",
+                    "987e6543-21ba-12d3-a456-426614174000",
+                    "abcddcba-98fe-76dc-a456-426614174000"
+                )
+            #>
+            $objectids = Get-CISExoOutput -Rec $recnum
+            # Step: Retrieve user details from Azure AD
+            # $users Mock Object
+            <#
+                $accountDetails = @(
+                    [PSCustomObject]@{
+                        ObjectId = "123e4567-e89b-12d3-a456-426614174000"
+                        DisplayName = "SMBuser1"
+                        AccountEnabled = $true
+                    },
+                    [PSCustomObject]@{
+                        ObjectId = "987e6543-21ba-12d3-a456-426614174000"
+                        DisplayName = "SMBuser2"
+                        AccountEnabled = $true
+                    },
+                    [PSCustomObject]@{
+                        ObjectId = "abcddcba-98fe-76dc-a456-426614174000"
+                        DisplayName = "SMBuser3"
+                        AccountEnabled = $true
+                    }
+                )
+            #>
+            $users = Get-CISMgOutput -Rec $recnum
+            # Step: Retrieve details of shared mailboxes from Azure AD (Condition B: Pass/Fail)
+            $sharedMailboxDetails = $users | Where-Object {$_.id -in $objectids}
+            # Step: Identify enabled mailboxes (Condition B: Pass/Fail)
+            $enabledMailboxes = $sharedMailboxDetails | Where-Object { $_.AccountEnabled } | ForEach-Object { $_.DisplayName }
+            $allBlocked = $enabledMailboxes.Count -eq 0
+            # Step: Determine failure reasons based on enabled mailboxes (Condition A & B: Fail)
+            $failureReasons = if (-not $allBlocked) {
+                "Some mailboxes have sign-in enabled (AccountEnabled:True):`n$($enabledMailboxes -join ', ')"
+            }
+            else {
+                "N/A"
+            }
+            # Step: Prepare details for the audit result (Condition A & B: Pass/Fail)
+            $details = if ($allBlocked) {
+                "All shared mailboxes have sign-in blocked."
+            }
+            else {
+                "AccountEnabled set to True Mailboxes: $($enabledMailboxes -join ', ')"
+            }
+            # Step: Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $allBlocked  # Pass: Condition A, Condition B
+                Status        = if ($allBlocked) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-CommonAttachmentFilter.ps1

@@ -1,46 +1,73 @@
 function Test-CommonAttachmentFilter {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be added if needed
     )
-
     begin {
-
-        $auditResults = @()
+        <#
+            Conditions for 2.1.2 (L1) Ensure the Common Attachment Types Filter is enabled
+            Validate test for a pass:
+            - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            - Specific conditions to check:
+                - Condition A: The Common Attachment Types Filter is enabled in the Microsoft 365 Security & Compliance Center.
+                - Condition B: Using Exchange Online PowerShell, verify that the `EnableFileFilter` property of the default malware filter policy is set to `True`.
+                - Condition C: Ensure that the setting is enabled in the highest priority policy listed if custom policies exist.
+            Validate test for a fail:
+            - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            - Specific conditions to check:
+                - Condition A: The Common Attachment Types Filter is not enabled in the Microsoft 365 Security & Compliance Center.
+                - Condition B: Using Exchange Online PowerShell, verify that the `EnableFileFilter` property of the default malware filter policy is set to `False`.
+                - Condition C: Ensure that the setting is not enabled in the highest priority policy listed if custom policies exist.
+        #>
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "2.1.2"
+        Write-Verbose "Running Test-CommonAttachmentFilter for $recnum..."
     }
-
     process {
-        # 2.1.2 (L1) Ensure the Common Attachment Types Filter is enabled
-        # Pass if EnableFileFilter is set to True. Fail otherwise.
-
-        $attachmentFilter = Get-MalwareFilterPolicy -Identity Default | Select-Object EnableFileFilter
-        $result = $attachmentFilter.EnableFileFilter
-        $details = "File Filter Enabled: $($attachmentFilter.EnableFileFilter)"
-        $failureReason = if ($result) { "N/A" } else { "Common Attachment Types Filter is disabled" }
-        $status = if ($result) { "Pass" } else { "Fail" }
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.Status = $status
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.Rec = "2.1.2"
-        $auditResult.RecDescription = "Ensure the Common Attachment Types Filter is enabled"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "9.6"
-        $auditResult.CISDescription = "Block Unnecessary File Types"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-        $auditResult.Result = $result
-        $auditResult.Details = $details
-        $auditResult.FailureReason = $failureReason
-
-        $auditResults += $auditResult
+        try {
+            # 2.1.2 (L1) Ensure the Common Attachment Types Filter is enabled
+            # Condition A: The Common Attachment Types Filter is enabled in the Microsoft 365 Security & Compliance Center.
+            # Condition B: Using Exchange Online PowerShell, verify that the `EnableFileFilter` property of the default malware filter policy is set to `True`.
+            # Retrieve the attachment filter policy
+            # $result Mock Object
+            # $result = $true
+            $result = Get-CISExoOutput -Rec $recnum
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $result) {
+                # Condition A: The Common Attachment Types Filter is not enabled in the Microsoft 365 Security & Compliance Center.
+                # Condition B: Using Exchange Online PowerShell, verify that the `EnableFileFilter` property of the default malware filter policy is set to `False`.
+                "Common Attachment Types Filter is disabled"
+            }
+            else {
+                "N/A"
+            }
+            $details = if ($result) {
+                "File Filter Enabled: True"
+            }
+            else {
+                "File Filter Enabled: False"
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $result
+                Status        = if ($result) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-CustomerLockbox.ps1

@@ -1,40 +1,71 @@
 function Test-CustomerLockbox {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
-        # Define your parameters here
+        # Aligned
+        # Define your parameters here if needed
     )
 
     begin {
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
 
-        $auditResults = @()
+        # Initialization code, if needed
+        $recnum = "1.3.6"
+        Write-Verbose "Running Test-CustomerLockbox for $recnum..."
+        # Conditions for 1.3.6 (L2) Ensure the customer lockbox feature is enabled (Automated)
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: In the Microsoft 365 admin center, the box labeled "Customer Lockbox Requests" is checked.
+        #   - Condition B: Using the SecureScore portal, the Customer Lockbox feature is enabled.
+        #   - Condition C: Using PowerShell, the Customer Lockbox feature is set to `True`.
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: In the Microsoft 365 admin center, the box labeled "Customer Lockbox Requests" is not checked.
+        #   - Condition B: Using the SecureScore portal, the Customer Lockbox feature is not enabled.
+        #   - Condition C: Using PowerShell, the Customer Lockbox feature is not set to `True`.
     }
-
     process {
-        # 1.3.6 (L2) Ensure the customer lockbox feature is enabled
-        $orgConfig = Get-OrganizationConfig | Select-Object CustomerLockBoxEnabled
-        $customerLockboxEnabled = $orgConfig.CustomerLockBoxEnabled
-
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.Status = if ($customerLockboxEnabled) { "Pass" } else { "Fail" }
-        $auditResult.ELevel = "E5"
-        $auditResult.ProfileLevel = "L2"
-        $auditResult.Rec = "1.3.6"
-        $auditResult.RecDescription = "Ensure the customer lockbox feature is enabled"
-        $auditResult.CISControlVer = 'v8'
-        $auditResult.CISControl = "0.0" # As per the snapshot provided, this is explicitly not mapped
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $false
-        $auditResult.IG3 = $false
-        $auditResult.Result = $customerLockboxEnabled
-        $auditResult.Details = "Customer Lockbox Enabled: $customerLockboxEnabled"
-        $auditResult.FailureReason = if ($customerLockboxEnabled) { "N/A" } else { "Customer lockbox feature is not enabled." }
-
-        $auditResults += $auditResult
+        try {
+            # Step: Retrieve the organization configuration (Condition C: Pass/Fail)
+            # $customerLockboxEnabled Mock Object
+            # $customerLockboxEnabled = $true
+            $customerLockboxEnabled = Get-CISExoOutput -Rec $recnum
+            # Step: Prepare failure reasons and details based on compliance (Condition A, B, & C: Fail)
+            $failureReasons = if (-not $customerLockboxEnabled) {
+                "Customer lockbox feature is not enabled."
+            }
+            else {
+                "N/A"
+            }
+            # Step: Prepare details for the audit result (Condition A, B, & C: Pass/Fail)
+            $details = if ($customerLockboxEnabled) {
+                "Customer Lockbox Enabled: True"
+            }
+            else {
+                "Customer Lockbox Enabled: False"
+            }
+            # Step: Create and populate the CISAuditResult object
+            $params = @{
+                Rec            = $recnum
+                Result         = $customerLockboxEnabled
+                Status         = if ($customerLockboxEnabled) { "Pass" } else { "Fail" }
+                Details        = $details
+                FailureReason  = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-DialInBypassLobby.ps1

@@ -1,45 +1,73 @@
 function Test-DialInBypassLobby {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "8.5.4"
+        Write-Verbose "Running Test-DialInBypassLobby for $recnum..."
     }
-
     process {
-        # 8.5.4 (L1) Ensure users dialing in can't bypass the lobby
-
-        # Connect to Teams PowerShell using Connect-MicrosoftTeams
-
-        $CsTeamsMeetingPolicyPSTN = Get-CsTeamsMeetingPolicy -Identity Global | Select-Object -Property AllowPSTNUsersToBypassLobby
-        $PSTNBypassDisabled = -not $CsTeamsMeetingPolicyPSTN.AllowPSTNUsersToBypassLobby
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "0.0" # Explicitly Not Mapped as per the image provided
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-        $auditResult.Rec = "8.5.4"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $false # Set based on the CIS Controls image
-        $auditResult.IG2 = $false # Set based on the CIS Controls image
-        $auditResult.IG3 = $false # Set based on the CIS Controls image
-        $auditResult.RecDescription = "Ensure users dialing in can't bypass the lobby"
-        $auditResult.Result = $PSTNBypassDisabled
-        $auditResult.Details = "AllowPSTNUsersToBypassLobby is set to $($CsTeamsMeetingPolicyPSTN.AllowPSTNUsersToBypassLobby)"
-        $auditResult.FailureReason = if ($PSTNBypassDisabled) { "N/A" } else { "Users dialing in can bypass the lobby" }
-        $auditResult.Status = if ($PSTNBypassDisabled) { "Pass" } else { "Fail" }
-
-        $auditResults += $auditResult
+        try {
+            # 8.5.4 (L1) Ensure users dialing in can't bypass the lobby
+            #
+            # Validate test for a pass:
+            # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            # - Specific conditions to check:
+            #   - Condition A: The `AllowPSTNUsersToBypassLobby` setting in the Global Teams meeting policy is set to `False`.
+            #   - Condition B: Verification using the UI in the Microsoft Teams admin center confirms that "People dialing in can't bypass the lobby" is set to `Off`.
+            #   - Condition C: Ensure that individuals who dial in by phone must wait in the lobby until admitted by a meeting organizer, co-organizer, or presenter.
+            #
+            # Validate test for a fail:
+            # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            # - Specific conditions to check:
+            #   - Condition A: The `AllowPSTNUsersToBypassLobby` setting in the Global Teams meeting policy is not set to `False`.
+            #   - Condition B: Verification using the UI in the Microsoft Teams admin center shows that "People dialing in can't bypass the lobby" is not set to `Off`.
+            #   - Condition C: Individuals who dial in by phone are able to join the meeting directly without waiting in the lobby.
+            # Retrieve Teams meeting policy for PSTN users
+            # $CsTeamsMeetingPolicyPSTN Mock Object
+            <#
+                $CsTeamsMeetingPolicyPSTN = [PSCustomObject]@{
+                    AllowPSTNUsersToBypassLobby           = $true
+                }
+            #>
+            $CsTeamsMeetingPolicyPSTN = Get-CISMSTeamsOutput -Rec $recnum
+            $PSTNBypassDisabled = -not $CsTeamsMeetingPolicyPSTN.AllowPSTNUsersToBypassLobby
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $PSTNBypassDisabled) {
+                "Users dialing in can bypass the lobby"
+            }
+            else {
+                "N/A"
+            }
+            $details = if ($PSTNBypassDisabled) {
+                "AllowPSTNUsersToBypassLobby is set to False"
+            }
+            else {
+                "AllowPSTNUsersToBypassLobby is set to True"
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $PSTNBypassDisabled
+                Status        = if ($PSTNBypassDisabled) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-DisallowInfectedFilesDownload.ps1

@@ -1,41 +1,75 @@
 function Test-DisallowInfectedFilesDownload {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
-        # Define your parameters here
+        # Aligned
+        # Define your parameters here if needed
     )
-
     begin {
-        # Initialization code
-
-        $auditResult = [CISAuditResult]::new()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "7.3.1"
+        Write-Verbose "Running Test-DisallowInfectedFilesDownload for $recnum..."
     }
-
     process {
-        # 7.3.1 (L2) Ensure Office 365 SharePoint infected files are disallowed for download
-        $SPOTenantDisallowInfectedFileDownload = Get-SPOTenant | Select-Object DisallowInfectedFileDownload
-        $isDisallowInfectedFileDownloadEnabled = $SPOTenantDisallowInfectedFileDownload.DisallowInfectedFileDownload
-
-        # Populate the auditResult object with the required properties
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "10.1"
-        $auditResult.CISDescription = "Deploy and Maintain Anti-Malware Software"
-
-        $auditResult.Rec = "7.3.1"
-        $auditResult.ELevel = "E5"
-        $auditResult.ProfileLevel = "L2"
-        $auditResult.IG1 = $true
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-        $auditResult.RecDescription = "Ensure Office 365 SharePoint infected files are disallowed for download"
-
-        $auditResult.Result = $isDisallowInfectedFileDownloadEnabled
-        $auditResult.Details = "DisallowInfectedFileDownload: $($SPOTenantDisallowInfectedFileDownload.DisallowInfectedFileDownload)"
-        $auditResult.FailureReason = if (-not $isDisallowInfectedFileDownloadEnabled) { "Downloading infected files is not disallowed." } else { "N/A" }
-        $auditResult.Status = if ($isDisallowInfectedFileDownloadEnabled) { "Pass" } else { "Fail" }
+        try {
+            # 7.3.1 (L2) Ensure Office 365 SharePoint infected files are disallowed for download
+            #
+            # Validate test for a pass:
+            # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            # - Specific conditions to check:
+            #   - Condition A: The `DisallowInfectedFileDownload` setting is set to `True`.
+            #   - Condition B: The setting prevents users from downloading infected files as detected by Defender for Office 365.
+            #   - Condition C: Verification using the PowerShell command confirms that the setting is correctly configured.
+            #
+            # Validate test for a fail:
+            # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            # - Specific conditions to check:
+            #   - Condition A: The `DisallowInfectedFileDownload` setting is not set to `True`.
+            #   - Condition B: The setting does not prevent users from downloading infected files.
+            #   - Condition C: Verification using the PowerShell command indicates that the setting is incorrectly configured.
+            # Retrieve the SharePoint tenant configuration
+            # $SPOTenantDisallowInfectedFileDownload Mock Object
+            <#
+                $SPOTenantDisallowInfectedFileDownload = [PSCustomObject]@{
+                    DisallowInfectedFileDownload           = $false
+                }
+            #>
+            $SPOTenantDisallowInfectedFileDownload = Get-CISSpoOutput -Rec $recnum
+            # Condition A: The `DisallowInfectedFileDownload` setting is set to `True`
+            $isDisallowInfectedFileDownloadEnabled = $SPOTenantDisallowInfectedFileDownload.DisallowInfectedFileDownload
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $isDisallowInfectedFileDownloadEnabled) {
+                "Downloading infected files is not disallowed. To ensure infected files cannot be downloaded, use the following command:`n" + ` # Condition B: The setting does not prevent users from downloading infected files
+                "Set-SPOTenant -DisallowInfectedFileDownload `$true"
+            }
+            else {
+                "N/A"
+            }
+            $details = if ($isDisallowInfectedFileDownloadEnabled) {
+                "DisallowInfectedFileDownload: True"  # Condition C: Verification confirms the setting is correctly configured
+            }
+            else {
+                "DisallowInfectedFileDownload: False"  # Condition C: Verification indicates the setting is incorrectly configured
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $isDisallowInfectedFileDownloadEnabled
+                Status        = if ($isDisallowInfectedFileDownloadEnabled) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResult
+        # Return the audit result
         return $auditResult
     }
-}
+}

source/tests/Test-EnableDKIM.ps1

@@ -1,44 +1,82 @@
 function Test-EnableDKIM {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be added if needed
+        [string]$DomainName
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "2.1.9"
+        Write-Verbose "Running Test-EnableDKIM for $recnum..."
+        <#
+        Conditions for 2.1.9 (L1) Ensure DKIM is enabled for all Exchange Online Domains (Automated)
+        Validate test for a pass:
+        - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        - Specific conditions to check:
+          - Condition A: DKIM is enabled for all Exchange Online domains in the Microsoft 365 security center.
+          - Condition B: Using the Exchange Online PowerShell Module, the `CnameConfiguration.Enabled` property for each domain is set to `True`.
+        Validate test for a fail:
+        - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        - Specific conditions to check:
+          - Condition A: DKIM is not enabled for one or more Exchange Online domains in the Microsoft 365 security center.
+          - Condition B: Using the Exchange Online PowerShell Module, the `CnameConfiguration.Enabled` property for one or more domains is set to `False`.
+        #>
     }
-
     process {
-        # 2.1.9 (L1) Ensure DKIM is enabled for all Exchange Online Domains
-        # Pass if Enabled is True for all domains. Fail if any domain has Enabled set to False.
-        $dkimConfig = Get-DkimSigningConfig | Select-Object Domain, Enabled
-        $dkimResult = ($dkimConfig | ForEach-Object { $_.Enabled }) -notcontains $false
-        $dkimFailedDomains = $dkimConfig | Where-Object { -not $_.Enabled } | ForEach-Object { $_.Domain }
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.Status = if ($dkimResult) { "Pass" } else { "Fail" }
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.Rec = "2.1.9"
-        $auditResult.RecDescription = "Ensure that DKIM is enabled for all Exchange Online Domains"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "9.5"
-        $auditResult.CISDescription = "Implement DMARC"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-        $auditResult.Result = $dkimResult
-        $auditResult.Details = if (-not $dkimResult) { "DKIM not enabled for: $($dkimFailedDomains -join ', ')" } else { "All domains have DKIM enabled" }
-        $auditResult.FailureReason = if (-not $dkimResult) { "DKIM is not enabled for some domains" } else { "N/A" }
-
-        $auditResults += $auditResult
+        try {
+            # 2.1.9 (L1) Ensure DKIM is enabled for all Exchange Online Domains
+            # Retrieve DKIM configuration for all domains
+            $dkimConfig = Get-CISExoOutput -Rec $recnum
+            if (-not $DomainName) {
+                $dkimResult = ($dkimConfig | ForEach-Object { $_.Enabled }) -notcontains $false
+                $dkimFailedDomains = $dkimConfig | Where-Object { -not $_.Enabled } | ForEach-Object { $_.Domain }
+            }
+            else {
+                $dkimResult = ($dkimConfig | Where-Object { $_.Domain -eq $DomainName }).Enabled
+                if ($dkimResult -eq $false) {
+                    $dkimFailedDomains = $dkimConfig | Where-Object { $_.Domain -eq $DomainName } | ForEach-Object { $_.Domain }
+                }
+            }
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $dkimResult) {
+                "DKIM is not enabled for some domains"  # Condition A fail
+            }
+            else {
+                "N/A"
+            }
+            $basedetails = "All domains have DKIM enabled"
+            $details = if ($dkimResult) {
+                if ($DomainName) {
+                    "Domain: $DomainName; $basedetails"
+                }
+                else {
+                    $basedetails
+                }  # Condition A pass
+            }
+            else {
+                "DKIM not enabled for: $($dkimFailedDomains -join ', ')"  # Condition B fail
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $dkimResult
+                Status        = if ($dkimResult) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
-}
+}

source/tests/Test-ExternalNoControl.ps1

@@ -1,45 +1,74 @@
 function Test-ExternalNoControl {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        # . .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "8.5.7"
+        Write-Verbose "Running Test-ExternalNoControl for $recnum..."
     }
-
     process {
-        # 8.5.7 (L1) Ensure external participants can't give or request control
-
-        # Connect to Teams PowerShell using Connect-MicrosoftTeams
-
-        $CsTeamsMeetingPolicyControl = Get-CsTeamsMeetingPolicy -Identity Global | Select-Object -Property AllowExternalParticipantGiveRequestControl
-        $externalControlRestricted = -not $CsTeamsMeetingPolicyControl.AllowExternalParticipantGiveRequestControl
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "0.0" # Explicitly Not Mapped as per the image provided
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-        $auditResult.Rec = "8.5.7"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $false # Set based on the CIS Controls image
-        $auditResult.IG2 = $false # Set based on the CIS Controls image
-        $auditResult.IG3 = $false # Set based on the CIS Controls image
-        $auditResult.RecDescription = "Ensure external participants can't give or request control"
-        $auditResult.Result = $externalControlRestricted
-        $auditResult.Details = "AllowExternalParticipantGiveRequestControl is set to $($CsTeamsMeetingPolicyControl.AllowExternalParticipantGiveRequestControl)"
-        $auditResult.FailureReason = if ($externalControlRestricted) { "N/A" } else { "External participants can give or request control" }
-        $auditResult.Status = if ($externalControlRestricted) { "Pass" } else { "Fail" }
-
-        $auditResults += $auditResult
+        try {
+            # 8.5.7 (L1) Ensure external participants can't give or request control
+            #
+            # Validate test for a pass:
+            # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            # - Specific conditions to check:
+            #   - Condition A: Ensure the `AllowExternalParticipantGiveRequestControl` setting in Teams is set to `False`.
+            #   - Condition B: The setting is verified through the Microsoft Teams admin center or via PowerShell command.
+            #   - Condition C: Verification using the UI confirms that external participants are unable to give or request control.
+            #
+            # Validate test for a fail:
+            # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            # - Specific conditions to check:
+            #   - Condition A: The `AllowExternalParticipantGiveRequestControl` setting in Teams is not set to `False`.
+            #   - Condition B: The setting is verified through the Microsoft Teams admin center or via PowerShell command.
+            #   - Condition C: Verification using the UI indicates that external participants can give or request control.
+            # Retrieve Teams meeting policy for external participant control
+            # $CsTeamsMeetingPolicyControl Mock Object
+            <#
+                $CsTeamsMeetingPolicyControl = [PSCustomObject]@{
+                    AllowExternalParticipantGiveRequestControl           = $true
+                }
+            #>
+            $CsTeamsMeetingPolicyControl = Get-CISMSTeamsOutput -Rec $recnum
+            # Check if external participants can give or request control
+            $externalControlRestricted = -not $CsTeamsMeetingPolicyControl.AllowExternalParticipantGiveRequestControl
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $externalControlRestricted) {
+                "External participants can give or request control"
+            }
+            else {
+                "N/A"
+            }
+            $details = if ($externalControlRestricted) {
+                "AllowExternalParticipantGiveRequestControl is set to False"
+            }
+            else {
+                "AllowExternalParticipantGiveRequestControl is set to True"
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec            = $recnum
+                Result         = $externalControlRestricted
+                Status         = if ($externalControlRestricted) { "Pass" } else { "Fail" }
+                Details        = $details
+                FailureReason  = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-ExternalSharingCalendars.ps1

@@ -1,53 +1,106 @@
 function Test-ExternalSharingCalendars {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be added if needed
     )
 
     begin {
-        # Dot source the class script
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
 
-        $auditResults = @()
+        # Initialization code, if needed
+        $recnum = "1.3.3"
+
+        # Conditions for 1.3.3 (L2) Ensure 'External sharing' of calendars is not available (Automated)
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: In the Microsoft 365 admin center, external calendar sharing is disabled.
+        #   - Condition B: Using the Exchange Online PowerShell Module, the `OrganizationConfig` property `ExternalSharingEnabled` is set to `False`.
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: In the Microsoft 365 admin center, external calendar sharing is enabled.
+        #   - Condition B: Using the Exchange Online PowerShell Module, the `OrganizationConfig` property `ExternalSharingEnabled` is set to `True`.
     }
 
     process {
-        # 1.3.3 (L2) Ensure 'External sharing' of calendars is not available (Automated)
-        $sharingPolicies = Get-SharingPolicy | Where-Object { $_.Domains -like '*CalendarSharing*' }
+        try {
+            # Step: Retrieve sharing policies related to calendar sharing
+            $sharingPolicies = Get-CISExoOutput -Rec $recnum
 
-        # Check if calendar sharing is disabled in all applicable policies
-        $isExternalSharingDisabled = $true
-        $sharingPolicyDetails = @()
-        foreach ($policy in $sharingPolicies) {
-            if ($policy.Enabled -eq $true) {
-                $isExternalSharingDisabled = $false
-                $sharingPolicyDetails += "$($policy.Name): Enabled"
+            # Step (Condition A & B: Pass/Fail): Check if calendar sharing is disabled in all applicable policies
+            $isExternalSharingDisabled = $true
+            $sharingPolicyDetails = @()
+            foreach ($policy in $sharingPolicies) {
+                if ($policy.Enabled -eq $true) {
+                    $isExternalSharingDisabled = $false
+                    $sharingPolicyDetails += "$($policy.Name): Enabled"
+                }
             }
+            $failureRemediation = @'
+# Get all mailboxes
+$mailboxes = Get-Mailbox -ResultSize Unlimited
+
+# Initialize a hashtable to store calendar folder names
+$calendarFolders = @{}
+# Get the default calendar folder names for all mailboxes
+$mailboxes | ForEach-Object {
+    $calendarFolderName = [string](Get-EXOMailboxFolderStatistics $_.PrimarySmtpAddress -FolderScope Calendar | Where-Object { $_.FolderType -eq 'Calendar' }).Name
+    $calendarFolders[$_.PrimarySmtpAddress] = $calendarFolderName
+}
+# Get the calendar folder settings for each mailbox
+foreach ($mailbox in $mailboxes) {
+    $primarySmtpAddress = $mailbox.PrimarySmtpAddress
+    $calendarFolder = $calendarFolders[$primarySmtpAddress]
+    # Get users calendar folder settings for their default Calendar folder
+    $calendar = Get-MailboxCalendarFolder -Identity "$primarySmtpAddress:\$calendarFolder"
+    # Check if calendar publishing is enabled and display a message
+    if ($calendar.PublishEnabled) {
+        Write-Host -ForegroundColor Yellow "Calendar publishing is enabled for $primarySmtpAddress on $($calendar.PublishedCalendarUrl)"
+    }
+}
+'@
+            # Step: Prepare failure reasons and details based on compliance (Condition A & B: Fail)
+            $failureReasons = if (-not $isExternalSharingDisabled) {
+                "Calendar sharing with external users is enabled in one or more policies.`n`n" + `
+                "Use the following command to verify which users are sharing calendars prior to disabling:`n`n" + `
+                $failureRemediation
+            }
+            else {
+                "N/A"
+            }
+
+            # Step: Prepare details for the audit result (Condition A & B: Pass/Fail)
+            $details = if ($isExternalSharingDisabled) {
+                "Calendar sharing with external users is disabled."
+            }
+            else {
+                "Enabled Sharing Policies: $($sharingPolicyDetails -join ', ')"
+            }
+
+            # Step: Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $isExternalSharingDisabled
+                Status        = if ($isExternalSharingDisabled) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.Rec = "1.3.3"
-        $auditResult.RecDescription = "Ensure 'External sharing' of calendars is not available"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L2"
-        # The following IG values are placeholders. Replace with actual values when known.
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-        $auditResult.CISControlVer = "v8"
-        # Placeholder for CIS Control, to be replaced with the actual value when available
-        $auditResult.CISControl = "4.8"
-        $auditResult.CISDescription = "Uninstall or Disable Unnecessary Services on Enterprise Assets and Software"
-        $auditResult.Result = $isExternalSharingDisabled
-        $auditResult.Details = if ($isExternalSharingDisabled) { "Calendar sharing with external users is disabled." } else { "Enabled Sharing Policies: $($sharingPolicyDetails -join ', ')" }
-        $auditResult.FailureReason = if ($isExternalSharingDisabled) { "N/A" } else { "Calendar sharing with external users is enabled in one or more policies." }
-        $auditResult.Status = if ($isExternalSharingDisabled) { "Pass" } else { "Fail" }
-
-        $auditResults += $auditResult
     }
 
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-GlobalAdminsCount.ps1

@@ -1,46 +1,69 @@
 function Test-GlobalAdminsCount {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
-        # Define your parameters here
+        # Define your parameters here if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+                # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Conditions for 1.1.3 (L1) Ensure that between two and four global admins are designated
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: The number of global admins is at least 2.
+        #   - Condition B: The number of global admins is at most 4.
+        #   - Condition C: The list of global admin usernames is accurately retrieved and displayed.
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: The number of global admins is less than 2.
+        #   - Condition B: The number of global admins is more than 4.
+        #   - Condition C: Any discrepancies or errors in retrieving the list of global admin usernames.
+        # Initialization code, if needed
+        $recnum = "1.1.3"
+        Write-Verbose "Starting Test-GlobalAdminsCount with Rec: $recnum"
     }
-
     process {
-        # 1.1.3 (L1) Ensure that between two and four global admins are designated
-        # Pass if the count of global admins is between 2 and 4. Fail otherwise.
-
-        $globalAdminRole = Get-MgDirectoryRole -Filter "RoleTemplateId eq '62e90394-69f5-4237-9190-012177145e10'"
-        $globalAdmins = Get-MgDirectoryRoleMember -DirectoryRoleId $globalAdminRole.Id
-        $globalAdminCount = $globalAdmins.AdditionalProperties.Count
-        $globalAdminUsernames = ($globalAdmins | ForEach-Object { $_.AdditionalProperties["displayName"] }) -join ', '
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "5.1"
-        $auditResult.CISDescription = "Establish and Maintain an Inventory of Accounts"
-        $auditResult.Rec = "1.1.3"
-        $auditResult.ELevel = "E3" # Based on your environment (E3, E5, etc.)
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $true # Set based on the benchmark
-        $auditResult.IG2 = $true # Set based on the benchmark
-        $auditResult.IG3 = $true # Set based on the benchmark
-        $auditResult.RecDescription = "Ensure that between two and four global admins are designated"
-        $auditResult.Result = $globalAdminCount -ge 2 -and $globalAdminCount -le 4
-        $auditResult.Details = "Count: $globalAdminCount; Users: $globalAdminUsernames"
-        $auditResult.FailureReason = if ($globalAdminCount -lt 2) { "Less than 2 global admins: $globalAdminUsernames" } elseif ($globalAdminCount -gt 4) { "More than 4 global admins: $globalAdminUsernames" } else { "N/A" }
-        $auditResult.Status = if ($globalAdminCount -ge 2 -and $globalAdminCount -le 4) { "Pass" } else { "Fail" }
-
-        $auditResults += $auditResult
+        try {
+            $globalAdmins = Get-CISMgOutput -Rec $recnum
+            # Step: Count the number of global admins
+            $globalAdminCount = $globalAdmins.Count
+            # Step: Retrieve and format the usernames of global admins
+            $globalAdminUsernames = ($globalAdmins | ForEach-Object {
+                "$($_.AdditionalProperties["displayName"]) ($($_.AdditionalProperties["userPrincipalName"]))"
+            }) -join ', '
+            # Step: Determine failure reasons based on global admin count
+            $failureReasons = if ($globalAdminCount -lt 2) {
+                "Less than 2 global admins: $globalAdminUsernames"
+            }
+            elseif ($globalAdminCount -gt 4) {
+                "More than 4 global admins: $globalAdminUsernames"
+            }
+            else {
+                "N/A"
+            }
+            # Step: Prepare details for the audit result
+            $details = "Count: $globalAdminCount; Users: $globalAdminUsernames"
+            # Step: Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $globalAdminCount -ge 2 -and $globalAdminCount -le 4
+                Status        = if ($globalAdminCount -ge 2 -and $globalAdminCount -le 4) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-GuestAccessExpiration.ps1

@@ -1,41 +1,70 @@
 function Test-GuestAccessExpiration {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
-        # Define your parameters here
+        # Aligned
+        # Define your parameters here if needed
     )
-
     begin {
-        # Initialization code
-
-        $auditResult = [CISAuditResult]::new()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "7.2.9"
+        Write-Verbose "Running Test-GuestAccessExpiration for $recnum..."
     }
-
     process {
-        # 7.2.9 (L1) Ensure guest access to a site or OneDrive will expire automatically
-        $SPOTenantGuestAccess = Get-SPOTenant | Select-Object ExternalUserExpirationRequired, ExternalUserExpireInDays
-        $isGuestAccessExpirationConfiguredCorrectly = $SPOTenantGuestAccess.ExternalUserExpirationRequired -and $SPOTenantGuestAccess.ExternalUserExpireInDays -le 30
-
-        # Populate the auditResult object with the required properties
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "0.0"
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-
-        $auditResult.Rec = "7.2.9"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $false
-        $auditResult.IG3 = $false
-        $auditResult.RecDescription = "Ensure guest access to a site or OneDrive will expire automatically"
-
-        $auditResult.Result = $isGuestAccessExpirationConfiguredCorrectly
-        $auditResult.Details = "ExternalUserExpirationRequired: $($SPOTenantGuestAccess.ExternalUserExpirationRequired); ExternalUserExpireInDays: $($SPOTenantGuestAccess.ExternalUserExpireInDays)"
-        $auditResult.FailureReason = if (-not $isGuestAccessExpirationConfiguredCorrectly) { "Guest access expiration is not configured to automatically expire within 30 days or less." } else { "N/A" }
-        $auditResult.Status = if ($isGuestAccessExpirationConfiguredCorrectly) { "Pass" } else { "Fail" }
+        try {
+            # 7.2.9 (L1) Ensure guest access to a site or OneDrive will expire automatically
+            #
+            # Validate test for a pass:
+            # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            # - Specific conditions to check:
+            #   - Condition A: The ExternalUserExpirationRequired setting in SharePoint is set to True.
+            #   - Condition B: The ExternalUserExpireInDays setting in SharePoint is configured to 30 or less.
+            #   - Condition C: Verification using the SharePoint Admin Center confirms that guest access will expire automatically after the specified number of days.
+            #
+            # Validate test for a fail:
+            # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            # - Specific conditions to check:
+            #   - Condition A: The ExternalUserExpirationRequired setting in SharePoint is not set to True.
+            #   - Condition B: The ExternalUserExpireInDays setting in SharePoint is configured to more than 30 days.
+            #   - Condition C: Verification using the SharePoint Admin Center indicates that guest access is not set to expire automatically after the specified number of days.
+            # Retrieve SharePoint tenant settings related to guest access expiration
+            # $SPOTenantGuestAccess Mock Object
+            <#
+                $SPOTenantGuestAccess = [PSCustomObject]@{
+                    ExternalUserExpirationRequired           = "$false"
+                    ExternalUserExpireInDays                 = "60"
+                }
+            #>
+            $SPOTenantGuestAccess = Get-CISSpoOutput -Rec $recnum
+            $isGuestAccessExpirationConfiguredCorrectly = $SPOTenantGuestAccess.ExternalUserExpirationRequired -and $SPOTenantGuestAccess.ExternalUserExpireInDays -le 30
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $isGuestAccessExpirationConfiguredCorrectly) {
+                "Guest access expiration is not configured to automatically expire within 30 days or less. To remediate this setting, use the Set-SPOTenant command:`n`n" + `
+                "Set-SPOTenant -ExternalUserExpirationRequired `$true -ExternalUserExpireInDays 30"
+            }
+            else {
+                "N/A"
+            }
+            $details = "ExternalUserExpirationRequired: $($SPOTenantGuestAccess.ExternalUserExpirationRequired); ExternalUserExpireInDays: $($SPOTenantGuestAccess.ExternalUserExpireInDays)"
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec            = $recnum
+                Result         = $isGuestAccessExpirationConfiguredCorrectly
+                Status         = if ($isGuestAccessExpirationConfiguredCorrectly) { "Pass" } else { "Fail" }
+                Details        = $details
+                FailureReason  = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResult
+        # Return the audit result
         return $auditResult
     }
 }

source/tests/Test-GuestUsersBiweeklyReview.ps1

@@ -0,0 +1,62 @@
+function Test-GuestUsersBiweeklyReview {
+    [CmdletBinding()]
+    [OutputType([CISAuditResult])]
+    param (
+        # Aligned
+        # Define your parameters here if needed
+    )
+
+    begin {
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+
+        # Initialization code, if needed
+        $recnum = "1.1.4"
+    }
+
+    process {
+        try {
+            # 1.1.4 (L1) Ensure Guest Users are reviewed at least biweekly
+
+
+            # Retrieve guest users from Microsoft Graph
+            # Connect-MgGraph -Scopes "User.Read.All"
+            $guestUsers = Get-MgUser -All -Filter "UserType eq 'Guest'"
+
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if ($guestUsers) {
+                "Guest users present: $($guestUsers.Count)"
+            }
+            else {
+                "N/A"
+            }
+
+            $details = if ($guestUsers) {
+                $auditCommand = "Get-MgUser -All -Property UserType,UserPrincipalName | Where {`$_.UserType -ne 'Member'} | Format-Table UserPrincipalName, UserType"
+                "Manual review required. To list guest users, run: `"$auditCommand`"."
+            }
+            else {
+                "No guest users found."
+            }
+
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = -not $guestUsers
+                Status        = if ($guestUsers) { "Fail" } else { "Pass" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
+    }
+
+    end {
+        # Return the audit result
+        return $auditResult
+    }
+}

source/tests/Test-IdentifyExternalEmail.ps1

@@ -1,44 +1,66 @@
 function Test-IdentifyExternalEmail {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be defined here if needed
     )
 
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "6.2.3"
+        Write-Verbose "Running Test-IdentifyExternalEmail for $recnum..."
+        # Conditions for 6.2.3 (L1) Ensure email from external senders is identified
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: External tagging is enabled using PowerShell for all identities.
+        #   - Condition B: The BypassAllowList only contains email addresses the organization has permitted to bypass external tagging.
+        #   - Condition C: External sender tag appears in email messages received from external sources.
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: External tagging is not enabled using PowerShell for all identities.
+        #   - Condition B: The BypassAllowList contains unauthorized email addresses.
+        #   - Condition C: External sender tag does not appear in email messages received from external sources.
     }
-
     process {
-        # 6.2.3 (L1) Ensure email from external senders is identified
-        # Requirement is to have external sender tagging enabled
-
-        $externalInOutlook = Get-ExternalInOutlook
-        $externalTaggingEnabled = ($externalInOutlook | ForEach-Object { $_.Enabled }) -contains $true
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.Status = if ($externalTaggingEnabled) { "Pass" } else { "Fail" }
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.Rec = "6.2.3"
-        $auditResult.RecDescription = "Ensure email from external senders is identified"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "0.0"
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $false
-        $auditResult.IG3 = $false
-        $auditResult.Result = $externalTaggingEnabled
-        $auditResult.Details = "Enabled: $($externalTaggingEnabled); AllowList: $($externalInOutlook.AllowList)"
-        $auditResult.FailureReason = if (-not $externalTaggingEnabled) { "External sender tagging is disabled" } else { "N/A" }
-
-        $auditResults += $auditResult
+        try {
+            # 6.2.3 (L1) Ensure email from external senders is identified
+            # Retrieve external sender tagging configuration
+            $externalInOutlook = Get-CISExoOutput -Rec $recnum
+            $externalTaggingEnabled = ($externalInOutlook | ForEach-Object { $_.Enabled }) -contains $true
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $externalTaggingEnabled) {
+                # Condition A: External tagging is not enabled using PowerShell for all identities.
+                "External sender tagging is disabled"
+            }
+            else {
+                "N/A"
+            }
+            # Details for external tagging configuration
+            $details = "Enabled: $($externalTaggingEnabled); AllowList: $($externalInOutlook.AllowList)"
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $externalTaggingEnabled
+                Status        = if ($externalTaggingEnabled) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-LinkSharingRestrictions.ps1

@@ -1,42 +1,70 @@
 function Test-LinkSharingRestrictions {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Define your parameters here
         # Test behavior in prod
     )
-
     begin {
-        # Initialization code
-
-        $auditResult = [CISAuditResult]::new()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "7.2.7"
+        Write-Verbose "Running Test-LinkSharingRestrictions for $recnum..."
     }
-
     process {
-        # 7.2.7 (L1) Ensure link sharing is restricted in SharePoint and OneDrive
-        $SPOTenantLinkSharing = Get-SPOTenant | Select-Object DefaultSharingLinkType
-        $isLinkSharingRestricted = $SPOTenantLinkSharing.DefaultSharingLinkType -eq 'Direct' # Or 'SpecificPeople' as per the recommendation
-
-        # Populate the auditResult object with the required properties
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "3.3"
-        $auditResult.CISDescription = "Configure Data Access Control Lists"
-
-        $auditResult.Rec = "7.2.7"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $true
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-        $auditResult.RecDescription = "Ensure link sharing is restricted in SharePoint and OneDrive"
-
-        $auditResult.Result = $isLinkSharingRestricted
-        $auditResult.Details = "DefaultSharingLinkType: $($SPOTenantLinkSharing.DefaultSharingLinkType)"
-        $auditResult.FailureReason = if (-not $isLinkSharingRestricted) { "Link sharing is not restricted to 'Specific people'. Current setting: $($SPOTenantLinkSharing.DefaultSharingLinkType)" } else { "N/A" }
-        $auditResult.Status = if ($isLinkSharingRestricted) { "Pass" } else { "Fail" }
+        try {
+            # 7.2.7 (L1) Ensure link sharing is restricted in SharePoint and OneDrive
+            #
+            # Validate test for a pass:
+            # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            # - Specific conditions to check:
+            #   - Condition A: The `DefaultSharingLinkType` setting in SharePoint and OneDrive is set to `Direct`.
+            #   - Condition B: The setting `Choose the type of link that's selected by default when users share files and folders in SharePoint and OneDrive` is set to `Specific people (only the people the user specifies)`.
+            #   - Condition C: Verification using the UI confirms that the link sharing settings are configured as recommended.
+            #
+            # Validate test for a fail:
+            # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            # - Specific conditions to check:
+            #   - Condition A: The `DefaultSharingLinkType` setting in SharePoint and OneDrive is not set to `Direct`.
+            #   - Condition B: The setting `Choose the type of link that's selected by default when users share files and folders in SharePoint and OneDrive` is not set to `Specific people (only the people the user specifies)`.
+            #   - Condition C: Verification using the UI indicates that the link sharing settings are not configured as recommended.
+            # Retrieve link sharing configuration for SharePoint and OneDrive
+            # $SPOTenantLinkSharing Mock Object
+            <#
+                $$SPOTenantLinkSharing = [PSCustomObject]@{
+                    DefaultSharingLinkType           = "Direct"
+                }
+            #>
+            $SPOTenantLinkSharing = Get-CISSpoOutput -Rec $recnum
+            $isLinkSharingRestricted = $SPOTenantLinkSharing.DefaultSharingLinkType -eq 'Direct'  # Or 'SpecificPeople' as per the recommendation
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $isLinkSharingRestricted) {
+                "Link sharing is not restricted to 'Specific people'. Current setting: $($SPOTenantLinkSharing.DefaultSharingLinkType). To remediate this setting, use the Set-SPOTenant command:`n`n" + `
+                "Set-SPOTenant -DefaultSharingLinkType Direct"
+            }
+            else {
+                "N/A"
+            }
+            $details = "DefaultSharingLinkType: $($SPOTenantLinkSharing.DefaultSharingLinkType)"
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $isLinkSharingRestricted
+                Status        = if ($isLinkSharingRestricted) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResult
+        # Return the audit result
         return $auditResult
     }
 }

source/tests/Test-MailTipsEnabled.ps1

@@ -1,43 +1,72 @@
 function Test-MailTipsEnabled {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
-        # Define your parameters here
+        # Aligned
+        # Parameters can be added if needed
     )
-
     begin {
-        # Initialization code
-
-        $auditResult = [CISAuditResult]::new()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "6.5.2"
+        Write-Verbose "Running Test-MailTipsEnabled for $recnum..."
+        # Conditions for 6.5.2 (L2) Ensure MailTips are enabled for end users
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: MailTipsAllTipsEnabled is set to True.
+        #   - Condition B: MailTipsExternalRecipientsTipsEnabled is set to True.
+        #   - Condition C: MailTipsGroupMetricsEnabled is set to True.
+        #   - Condition D: MailTipsLargeAudienceThreshold is set to an acceptable value (default is 25).
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: MailTipsAllTipsEnabled is not set to True.
+        #   - Condition B: MailTipsExternalRecipientsTipsEnabled is not set to True.
+        #   - Condition C: MailTipsGroupMetricsEnabled is not set to True.
+        #   - Condition D: MailTipsLargeAudienceThreshold is not set to an acceptable value (default is 25).
     }
-
     process {
-        # 6.5.2 (L2) Ensure MailTips are enabled for end users
-        $orgConfig = Get-OrganizationConfig | Select-Object MailTipsAllTipsEnabled, MailTipsExternalRecipientsTipsEnabled, MailTipsGroupMetricsEnabled, MailTipsLargeAudienceThreshold
-        $allTipsEnabled = $orgConfig.MailTipsAllTipsEnabled -and $orgConfig.MailTipsGroupMetricsEnabled -and $orgConfig.MailTipsLargeAudienceThreshold -eq 25
-        $externalRecipientsTipsEnabled = $orgConfig.MailTipsExternalRecipientsTipsEnabled
-
-        # Since there is no direct CIS Control mapping, the control will be set as not applicable.
-        $auditResult.CISControl = "0"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-
-        $auditResult.Rec = "6.5.2"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L2"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $false
-        $auditResult.IG3 = $false
-        $auditResult.RecDescription = "Ensure MailTips are enabled for end users"
-
-        $auditResult.Result = $allTipsEnabled -and $externalRecipientsTipsEnabled
-        $auditResult.Details = "MailTipsAllTipsEnabled: $($orgConfig.MailTipsAllTipsEnabled); MailTipsExternalRecipientsTipsEnabled: $($orgConfig.MailTipsExternalRecipientsTipsEnabled); MailTipsGroupMetricsEnabled: $($orgConfig.MailTipsGroupMetricsEnabled); MailTipsLargeAudienceThreshold: $($orgConfig.MailTipsLargeAudienceThreshold)"
-        $auditResult.FailureReason = if (-not $auditResult.Result) { "One or more MailTips settings are not configured as required." } else { "N/A" }
-        $auditResult.Status = if ($auditResult.Result) { "Pass" } else { "Fail" }
+        try {
+            # 6.5.2 (L2) Ensure MailTips are enabled for end users
+            # Retrieve organization configuration for MailTips settings
+            $orgConfig = Get-CISExoOutput -Rec $recnum
+            # Check the MailTips settings (Conditions A, B, C, D)
+            $allTipsEnabled = $orgConfig.MailTipsAllTipsEnabled -and $orgConfig.MailTipsGroupMetricsEnabled -and $orgConfig.MailTipsLargeAudienceThreshold -eq 25
+            $externalRecipientsTipsEnabled = $orgConfig.MailTipsExternalRecipientsTipsEnabled
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not ($allTipsEnabled -and $externalRecipientsTipsEnabled)) {
+                "One or more MailTips settings are not configured as required."
+            }
+            else {
+                "N/A"
+            }
+            $details = if ($allTipsEnabled -and $externalRecipientsTipsEnabled) {
+                "MailTipsAllTipsEnabled: $($orgConfig.MailTipsAllTipsEnabled); MailTipsExternalRecipientsTipsEnabled: $($orgConfig.MailTipsExternalRecipientsTipsEnabled); MailTipsGroupMetricsEnabled: $($orgConfig.MailTipsGroupMetricsEnabled); MailTipsLargeAudienceThreshold: $($orgConfig.MailTipsLargeAudienceThreshold)"
+            }
+            else {
+                "One or more MailTips settings are not configured as required."
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $allTipsEnabled -and $externalRecipientsTipsEnabled
+                Status        = if ($allTipsEnabled -and $externalRecipientsTipsEnabled) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResult
+        # Return the audit result
         return $auditResult
     }
 }
-

source/tests/Test-MailboxAuditingE3.ps1

@@ -1,111 +1,132 @@
 function Test-MailboxAuditingE3 {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
         # Parameters can be added if needed
     )
-
     begin {
-
-        $e3SkuPartNumbers = @("ENTERPRISEPACK", "OFFICESUBSCRIPTION")
-        $AdminActions = @("ApplyRecord", "Copy", "Create", "FolderBind", "HardDelete", "Move", "MoveToDeletedItems", "SendAs", "SendOnBehalf", "SoftDelete", "Update", "UpdateCalendarDelegation", "UpdateFolderPermissions", "UpdateInboxRules")
-        $DelegateActions = @("ApplyRecord", "Create", "FolderBind", "HardDelete", "Move", "MoveToDeletedItems", "SendAs", "SendOnBehalf", "SoftDelete", "Update", "UpdateFolderPermissions", "UpdateInboxRules")
-        $OwnerActions = @("ApplyRecord", "Create", "HardDelete", "MailboxLogin", "Move", "MoveToDeletedItems", "SoftDelete", "Update", "UpdateCalendarDelegation", "UpdateFolderPermissions", "UpdateInboxRules")
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.Rec = "6.1.2"
-        $auditResult.RecDescription = "Ensure mailbox auditing for Office E3 users is Enabled"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "8.2"
-        $auditResult.CISDescription = "Collect audit logs."
-        $auditResult.IG1 = $true
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-
+        <#
+        Conditions for 6.1.2 (L1) Ensure mailbox auditing for E3 users is Enabled
+        Validate test for a pass:
+        - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        - Specific conditions to check:
+          - Condition A: Mailbox audit logging is enabled for all user mailboxes.
+          - Condition B: The `AuditAdmin` actions include `ApplyRecord`, `Create`, `HardDelete`, `MoveToDeletedItems`, `SendAs`, `SendOnBehalf`, `SoftDelete`, `Update`, `UpdateCalendarDelegation`, `UpdateFolderPermissions`, and `UpdateInboxRules`.
+          - Condition C: The `AuditDelegate` actions include `ApplyRecord`, `Create`, `HardDelete`, `MoveToDeletedItems`, `SendAs`, `SendOnBehalf`, `SoftDelete`, `Update`, `UpdateFolderPermissions`, and `UpdateInboxRules`.
+          - Condition D: The `AuditOwner` actions include `ApplyRecord`, `HardDelete`, `MoveToDeletedItems`, `SoftDelete`, `Update`, `UpdateCalendarDelegation`, `UpdateFolderPermissions`, and `UpdateInboxRules`.
+        Validate test for a fail:
+        - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        - Specific conditions to check:
+          - Condition A: Mailbox audit logging is not enabled for all user mailboxes.
+          - Condition B: The `AuditAdmin` actions do not include `ApplyRecord`, `Create`, `HardDelete`, `MoveToDeletedItems`, `SendAs`, `SendOnBehalf`, `SoftDelete`, `Update`, `UpdateCalendarDelegation`, `UpdateFolderPermissions`, and `UpdateInboxRules`.
+          - Condition C: The `AuditDelegate` actions do not include `ApplyRecord`, `Create`, `HardDelete`, `MoveToDeletedItems`, `SendAs`, `SendOnBehalf`, `SoftDelete`, `Update`, `UpdateFolderPermissions`, and `UpdateInboxRules`.
+          - Condition D: The `AuditOwner` actions do not include `ApplyRecord`, `HardDelete`, `MoveToDeletedItems`, `SoftDelete`, `Update`, `UpdateCalendarDelegation`, `UpdateFolderPermissions`, and `UpdateInboxRules`.
+        #>
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        $recnum = "6.1.2"
+        $version = $recnum
+        $actionDictionaries = Get-Action -Dictionaries -Version $version
+        # E3 specific actions
+        $AdminActions = $actionDictionaries.AdminActions.Keys
+        $DelegateActions = $actionDictionaries.DelegateActions.Keys
+        $OwnerActions = $actionDictionaries.OwnerActions.Keys
         $allFailures = @()
-        $allUsers = Get-AzureADUser -All $true
+
+        Write-Verbose "Running Test-MailboxAuditingE3 for $recnum..."
+        $allUsers = Get-CISMgOutput -Rec $recnum
         $processedUsers = @{}  # Dictionary to track processed users
     }
-
     process {
-        foreach ($user in $allUsers) {
-            if ($processedUsers.ContainsKey($user.UserPrincipalName)) {
-                Write-Verbose "Skipping already processed user: $($user.UserPrincipalName)"
-                continue
-            }
+        if ($null -ne $allUsers) {
+            $mailboxes = Get-CISExoOutput -Rec $recnum
             try {
-                $licenseDetails = Get-MgUserLicenseDetail -UserId $user.UserPrincipalName
-                $hasOfficeE3 = ($licenseDetails | Where-Object { $_.SkuPartNumber -in $e3SkuPartNumbers }).Count -gt 0
-                Write-Verbose "Evaluating user $($user.UserPrincipalName) for Office E3 license."
-
-                if ($hasOfficeE3) {
+                foreach ($user in $allUsers) {
+                    if ($processedUsers.ContainsKey($user.UserPrincipalName)) {
+                        Write-Verbose "Skipping already processed user: $($user.UserPrincipalName)"
+                        continue
+                    }
                     $userUPN = $user.UserPrincipalName
-                    $mailbox = Get-EXOMailbox -Identity $userUPN -PropertySets Audit
-
-                    $missingActions = @()
+                    $mailbox = $mailboxes | Where-Object { $_.UserPrincipalName -eq $user.UserPrincipalName }
+                    $missingAdminActions = @()
+                    $missingDelegateActions = @()
+                    $missingOwnerActions = @()
                     if ($mailbox.AuditEnabled) {
                         foreach ($action in $AdminActions) {
-                            if ($mailbox.AuditAdmin -notcontains $action) { $missingActions += "Admin action '$action' missing" }
+                            if ($mailbox.AuditAdmin -notcontains $action) {
+                                $missingAdminActions += (Get-Action -Actions $action -ActionType "Admin" -Version $version)
+                            }
                         }
                         foreach ($action in $DelegateActions) {
-                            if ($mailbox.AuditDelegate -notcontains $action) { $missingActions += "Delegate action '$action' missing" }
+                            if ($mailbox.AuditDelegate -notcontains $action) {
+                                $missingDelegateActions += (Get-Action -Actions $action -ActionType "Delegate" -Version $version)
+                            }
                         }
                         foreach ($action in $OwnerActions) {
-                            if ($mailbox.AuditOwner -notcontains $action) { $missingActions += "Owner action '$action' missing" }
+                            if ($mailbox.AuditOwner -notcontains $action) {
+                                $missingOwnerActions += (Get-Action -Actions $action -ActionType "Owner" -Version $version)
+                            }
+                        }
+                        if ($missingAdminActions.Count -gt 0 -or $missingDelegateActions.Count -gt 0 -or $missingOwnerActions.Count -gt 0) {
+                            $allFailures += "$userUPN|True|$($missingAdminActions -join ',')|$($missingDelegateActions -join ',')|$($missingOwnerActions -join ',')"
                         }
                     }
                     else {
-                        $allFailures += "$userUPN`: AuditEnabled - False"
-                        continue
-                    }
-
-                    if ($missingActions) {
-                        $formattedActions = Format-MissingActions $missingActions
-                        $allFailures += "$userUPN`: AuditEnabled - True; $formattedActions"
+                        $allFailures += "$userUPN|False|||" # Condition A for fail
                     }
                     # Mark the user as processed
                     $processedUsers[$user.UserPrincipalName] = $true
                 }
+                # Prepare failure reasons and details based on compliance
+                if ($allFailures.Count -eq 0) {
+                    $failureReasons = "N/A"
+                }
+                else {
+                    $failureReasons = "Audit issues detected."
+                }
+                $details = if ($allFailures.Count -eq 0) {
+                    "All Office E3 users have correct mailbox audit settings."
+                }
+                else {
+                    "UserPrincipalName|AuditEnabled|AdminActionsMissing|DelegateActionsMissing|OwnerActionsMissing`n" + ($allFailures -join "`n")
+                }
+                # Populate the audit result
+                $params = @{
+                    Rec           = $recnum
+                    Result        = $allFailures.Count -eq 0
+                    Status        = if ($allFailures.Count -eq 0) { "Pass" } else { "Fail" }
+                    Details       = $details
+                    FailureReason = $failureReasons
+                }
+                $auditResult = Initialize-CISAuditResult @params
             }
             catch {
-                Write-Warning "Could not retrieve license details for user $($user.UserPrincipalName): $_"
+                Write-Error "An error occurred during the test $recnum`:: $_"
+                # Retrieve the description from the test definitions
+                $testDefinition = $script:TestDefinitionsObject | Where-Object { $_.Rec -eq $recnum }
+                $description = if ($testDefinition) { $testDefinition.RecDescription } else { "Description not found" }
+                $script:FailedTests.Add([PSCustomObject]@{ Rec = $recnum; Description = $description; Error = $_ })
+                # Call Initialize-CISAuditResult with error parameters
+                $auditResult = Initialize-CISAuditResult -Rec $recnum -Failure
             }
         }
-
-        $auditResult.Result = $allFailures.Count -eq 0
-        $auditResult.Status = if ($auditResult.Result) { "Pass" } else { "Fail" }
-        $auditResult.Details = if ($auditResult.Result) { "All Office E3 users have correct mailbox audit settings." } else { $allFailures -join " | " }
-        $auditResult.FailureReason = if (-not $auditResult.Result) { "Audit issues detected." } else { "N/A" }
+        else {
+            $params = @{
+                Rec           = $recnum
+                Result        = $false
+                Status        = "Fail"
+                Details       = "No M365 E3 licenses found."
+                FailureReason = "The audit is for M365 E3 licenses, but no such licenses were found."
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
     }
-
     end {
+        $detailsLength = $details.Length
+        Write-Verbose "Character count of the details: $detailsLength"
+        if ($detailsLength -gt 32767) {
+            Write-Verbose "Warning: The character count exceeds the limit for Excel cells."
+        }
         return $auditResult
     }
 }
-
-function Format-MissingActions {
-    param ([array]$missingActions)
-
-    $actionGroups = @{
-        "Admin"    = @()
-        "Delegate" = @()
-        "Owner"    = @()
-    }
-
-    foreach ($action in $missingActions) {
-        if ($action -match "(Admin|Delegate|Owner) action '([^']+)' missing") {
-            $type = $matches[1]
-            $actionName = $matches[2]
-            $actionGroups[$type] += $actionName
-        }
-    }
-
-    $formattedResults = @()
-    foreach ($type in $actionGroups.Keys) {
-        if ($actionGroups[$type].Count -gt 0) {
-            $formattedResults += "$($type) actions missing: $($actionGroups[$type] -join ', ')"
-        }
-    }
-
-    return $formattedResults -join '; '
-}

source/tests/Test-MailboxAuditingE5.ps1

@@ -1,120 +1,134 @@
 function Test-MailboxAuditingE5 {
     [CmdletBinding()]
-    param ()
-
+    [OutputType([CISAuditResult])]
+    param (
+        # Parameters can be added if needed
+    )
     begin {
-
-        $AdminActions = @("ApplyRecord", "Copy", "Create", "FolderBind", "HardDelete", "MailItemsAccessed", "Move", "MoveToDeletedItems", "SendAs", "SendOnBehalf", "Send", "SoftDelete", "Update", "UpdateCalendarDelegation", "UpdateFolderPermissions", "UpdateInboxRules")
-        $DelegateActions = @("ApplyRecord", "Create", "FolderBind", "HardDelete", "MailItemsAccessed", "Move", "MoveToDeletedItems", "SendAs", "SendOnBehalf", "SoftDelete", "Update", "UpdateFolderPermissions", "UpdateInboxRules")
-        $OwnerActions = @("ApplyRecord", "Create", "HardDelete", "MailboxLogin", "Move", "MailItemsAccessed", "MoveToDeletedItems", "Send", "SoftDelete", "Update", "UpdateCalendarDelegation", "UpdateFolderPermissions", "UpdateInboxRules")
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.ELevel = "E5"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.Rec = "6.1.3"
-        $auditResult.RecDescription = "Ensure mailbox auditing for Office E5 users is Enabled"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "8.2"
-        $auditResult.CISDescription = "Collect audit logs."
-        $auditResult.IG1 = $true
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Conditions for 6.1.3 (L1) Ensure mailbox auditing for E5 users is Enabled
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: Mailbox auditing is enabled for E5 users.
+        #   - Condition B: AuditAdmin actions include ApplyRecord, Create, HardDelete, MailItemsAccessed, MoveToDeletedItems, Send, SendAs, SendOnBehalf, SoftDelete, Update, UpdateCalendarDelegation, UpdateFolderPermissions, UpdateInboxRules.
+        #   - Condition C: AuditDelegate actions include ApplyRecord, Create, HardDelete, MailItemsAccessed, MoveToDeletedItems, SendAs, SendOnBehalf, SoftDelete, Update, UpdateFolderPermissions, UpdateInboxRules.
+        #   - Condition D: AuditOwner actions include ApplyRecord, HardDelete, MailItemsAccessed, MoveToDeletedItems, Send, SoftDelete, Update, UpdateCalendarDelegation, UpdateFolderPermissions, UpdateInboxRules.
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: Mailbox auditing is not enabled for E5 users.
+        #   - Condition B: AuditAdmin actions do not include all of the following: ApplyRecord, Create, HardDelete, MailItemsAccessed, MoveToDeletedItems, Send, SendAs, SendOnBehalf, SoftDelete, Update, UpdateCalendarDelegation, UpdateFolderPermissions, UpdateInboxRules.
+        #   - Condition C: AuditDelegate actions do not include all of the following: ApplyRecord, Create, HardDelete, MailItemsAccessed, MoveToDeletedItems, SendAs, SendOnBehalf, SoftDelete, Update, UpdateFolderPermissions, UpdateInboxRules.
+        #   - Condition D: AuditOwner actions do not include all of the following: ApplyRecord, HardDelete, MailItemsAccessed, MoveToDeletedItems, Send, SoftDelete, Update, UpdateCalendarDelegation, UpdateFolderPermissions, UpdateInboxRules.
+        $recnum = "6.1.3"
+        $version = $recnum
+        $actionDictionaries = Get-Action -Dictionaries -Version $version
+        $AdminActions = $actionDictionaries.AdminActions.Keys
+        $DelegateActions = $actionDictionaries.DelegateActions.Keys
+        $OwnerActions = $actionDictionaries.OwnerActions.Keys
         $allFailures = @()
-        $allUsers = Get-AzureADUser -All $true
-        $processedUsers = @{}  # Dictionary to track processed users
+        $processedUsers = @{}
+        Write-Verbose "Running Test-MailboxAuditingE5 for $recnum..."
+        $allUsers = Get-CISMgOutput -Rec $recnum
     }
-
     process {
-        foreach ($user in $allUsers) {
-            if ($processedUsers.ContainsKey($user.UserPrincipalName)) {
-                continue
-            }
-
+        if ($null -ne $allUsers) {
+            $mailboxes = Get-CISExoOutput -Rec $recnum
             try {
-                # Define SKU Part Numbers for Office E5 licenses
-                # Define SKU Part Numbers for Office E5 licenses
-                $e5SkuPartNumbers = @("SPE_E5", "ENTERPRISEPREMIUM", "OFFICEE5")
-                $licenseDetails = Get-MgUserLicenseDetail -UserId $user.UserPrincipalName
-                $hasOfficeE5 = ($licenseDetails | Where-Object { $_.SkuPartNumber -in $e5SkuPartNumbers }).Count -gt 0
-                Write-Verbose "Evaluating user $($user.UserPrincipalName) for Office E5 license."
-                if ($hasOfficeE5) {
-                    $userUPN = $user.UserPrincipalName
-
-                    $mailbox = Get-EXOMailbox -Identity $userUPN -PropertySets Audit
-
-                    $missingActions = @()
-                    if ($mailbox.AuditEnabled) {
-                        foreach ($action in $AdminActions) {
-                            if ($mailbox.AuditAdmin -notcontains $action) { $missingActions += "Admin action '$action' missing" }
-                        }
-                        foreach ($action in $DelegateActions) {
-                            if ($mailbox.AuditDelegate -notcontains $action) { $missingActions += "Delegate action '$action' missing" }
-                        }
-                        foreach ($action in $OwnerActions) {
-                            if ($mailbox.AuditOwner -notcontains $action) { $missingActions += "Owner action '$action' missing" }
-                        }
-                    }
-                    else {
-                        $allFailures += "$userUPN`: AuditEnabled - False"
+                foreach ($user in $allUsers) {
+                    if ($processedUsers.ContainsKey($user.UserPrincipalName)) {
+                        Write-Verbose "Skipping already processed user: $($user.UserPrincipalName)"
                         continue
                     }
-
-                    if ($missingActions) {
-                        $formattedActions = Format-MissingActions $missingActions
-                        $allFailures += "$userUPN`: AuditEnabled - True; $formattedActions"
+                    $mailbox = $mailboxes | Where-Object { $_.UserPrincipalName -eq $user.UserPrincipalName }
+                    $userUPN = $user.UserPrincipalName
+                    $missingAdminActions = @()
+                    $missingDelegateActions = @()
+                    $missingOwnerActions = @()
+                    if ($mailbox.AuditEnabled) {
+                        # Validate Admin actions
+                        foreach ($action in $AdminActions) {
+                            if ($mailbox.AuditAdmin -notcontains $action) {
+                                $missingAdminActions += (Get-Action -Actions $action -ActionType "Admin" -Version $version) # Condition B
+                            }
+                        }
+                        # Validate Delegate actions
+                        foreach ($action in $DelegateActions) {
+                            if ($mailbox.AuditDelegate -notcontains $action) {
+                                $missingDelegateActions += (Get-Action -Actions $action -ActionType "Delegate" -Version $version) # Condition C
+                            }
+                        }
+                        # Validate Owner actions
+                        foreach ($action in $OwnerActions) {
+                            if ($mailbox.AuditOwner -notcontains $action) {
+                                $missingOwnerActions += (Get-Action -Actions $action -ActionType "Owner" -Version $version) # Condition D
+                            }
+                        }
+                        if ($missingAdminActions.Count -gt 0 -or $missingDelegateActions.Count -gt 0 -or $missingOwnerActions.Count -gt 0) {
+                            $allFailures += "$userUPN|True|$($missingAdminActions -join ',')|$($missingDelegateActions -join ',')|$($missingOwnerActions -join ',')"
+                        }
                     }
                     else {
-                        Write-Verbose "User $($user.UserPrincipalName) passed the mailbox audit checks."
+                        $allFailures += "$userUPN|False|||" # Condition A for fail
                     }
+                    # Mark the user as processed
                     $processedUsers[$user.UserPrincipalName] = $true
                 }
-                else {
-                    # Adding verbose output to indicate the user does not have an E5 license
-                    Write-Verbose "User $($user.UserPrincipalName) does not have an Office E5 license."
+                # Prepare failure reasons and details based on compliance
+                if ($allFailures.Count -eq 0) {
+                    $failureReasons = "N/A"
                 }
+                else {
+                    $failureReasons = "Audit issues detected."
+                }
+                $details = if ($allFailures.Count -eq 0) {
+                    "All Office E5 users have correct mailbox audit settings." # Condition A for pass
+                }
+                else {
+                    "UserPrincipalName|AuditEnabled|AdminActionsMissing|DelegateActionsMissing|OwnerActionsMissing`n" + ($allFailures -join "`n") # Condition A for fail
+                }
+                # $details = Initialize-LargeTestTable -lineCount 3000 # Adjust the lineCount to exceed 32,000 characters
+                # Populate the audit result
+                $params = @{
+                    Rec           = $recnum
+                    Result        = $allFailures.Count -eq 0
+                    Status        = if ($allFailures.Count -eq 0) { "Pass" } else { "Fail" }
+                    Details       = $details
+                    FailureReason = $failureReasons
+                }
+                $auditResult = Initialize-CISAuditResult @params
             }
             catch {
-                Write-Warning "Could not retrieve license details for user $($user.UserPrincipalName): $_"
+                Write-Error "An error occurred during the test $recnum`:: $_"
+                # Retrieve the description from the test definitions
+                $testDefinition = $script:TestDefinitionsObject | Where-Object { $_.Rec -eq $recnum }
+                $description = if ($testDefinition) { $testDefinition.RecDescription } else { "Description not found" }
+                $script:FailedTests.Add([PSCustomObject]@{ Rec = $recnum; Description = $description; Error = $_ })
+                # Call Initialize-CISAuditResult with error parameters
+                $auditResult = Initialize-CISAuditResult -Rec $recnum -Failure
             }
         }
-
-        if ($allFailures.Count -eq 0) {
-            Write-Verbose "All evaluated E5 users have correct mailbox audit settings."
+        else {
+            $params = @{
+                Rec           = $recnum
+                Result        = $false
+                Status        = "Fail"
+                Details       = "No M365 E5 licenses found."
+                FailureReason = "The audit is for M365 E5 licenses, but no such licenses were found."
+            }
+            $auditResult = Initialize-CISAuditResult @params
         }
-        $auditResult.Result = $allFailures.Count -eq 0
-        $auditResult.Status = if ($auditResult.Result) { "Pass" } else { "Fail" }
-        $auditResult.Details = if ($auditResult.Result) { "All Office E5 users have correct mailbox audit settings." } else { $allFailures -join " | " }
-        $auditResult.FailureReason = if (-not $auditResult.Result) { "Audit issues detected." } else { "N/A" }
     }
-
     end {
+        $detailsLength = $details.Length
+        Write-Verbose "Character count of the details: $detailsLength"
+        if ($detailsLength -gt 32767) {
+            Write-Verbose "Warning: The character count exceeds the limit for Excel cells."
+        }
         return $auditResult
     }
 }
-
-function Format-MissingActions {
-    param ([array]$missingActions)
-
-    $actionGroups = @{
-        "Admin"    = @()
-        "Delegate" = @()
-        "Owner"    = @()
-    }
-
-    foreach ($action in $missingActions) {
-        if ($action -match "(Admin|Delegate|Owner) action '([^']+)' missing") {
-            $type = $matches[1]
-            $actionName = $matches[2]
-            $actionGroups[$type] += $actionName
-        }
-    }
-
-    $formattedResults = @()
-    foreach ($type in $actionGroups.Keys) {
-        if ($actionGroups[$type].Count -gt 0) {
-            $formattedResults += "$($type) actions missing: $($actionGroups[$type] -join ', ')"
-        }
-    }
-
-    return $formattedResults -join '; '
-}

source/tests/Test-ManagedApprovedPublicGroups.ps1

@@ -1,54 +1,65 @@
 function Test-ManagedApprovedPublicGroups {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
-        # Define your parameters here
+        # Parameters can be added if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "1.2.1"
+        Write-Verbose "Starting Test-ManagedApprovedPublicGroups with Rec: $recnum"
+        # Conditions for 1.2.1 (L2) Ensure that only organizationally managed/approved public groups exist (Automated)
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: No groups have the status 'Public' in the privacy column on the Active teams and groups page.
+        #   - Condition B: Using Microsoft Graph PowerShell, all groups return a status other than 'Public' when checked.
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: One or more groups have the status 'Public' in the privacy column on the Active teams and groups page.
+        #   - Condition B: Using Microsoft Graph PowerShell, one or more groups return a status of 'Public' when checked.
     }
-
     process {
-        # 1.2.1 (L2) Ensure that only organizationally managed/approved public groups exist (Automated)
-
-        $allGroups = Get-MgGroup -All | Where-Object { $_.Visibility -eq "Public" } | Select-Object DisplayName, Visibility
-
-        # Check if there are public groups and if they are organizationally managed/approved
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "3.3"
-        $auditResult.CISDescription = "Configure Data Access Control Lists"
-        $auditResult.Rec = "1.2.1"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L2"
-        $auditResult.IG1 = $true
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true # Based on the provided CIS Control image, IG3 is not applicable
-        $auditResult.RecDescription = "Ensure that only organizationally managed/approved public groups exist"
-
-        if ($null -eq $allGroups -or $allGroups.Count -eq 0) {
-            $auditResult.Result = $true
-            $auditResult.Details = "No public groups found."
-            $auditResult.FailureReason = "N/A"
-            $auditResult.Status = "Pass"
+        try {
+            # Step: Retrieve all groups with visibility set to 'Public'
+            $allGroups = Get-CISMgOutput -Rec $recnum
+            # Step: Determine failure reasons based on the presence of public groups
+            $failureReasons = if ($null -ne $allGroups -and $allGroups.Count -gt 0) {
+                "There are public groups present that are not organizationally managed/approved."
+            }
+            else {
+                "N/A"
+            }
+            # Step: Prepare details for the audit result
+            $details = if ($null -eq $allGroups -or $allGroups.Count -eq 0) {
+                "No public groups found."
+            }
+            else {
+                $groupDetails = $allGroups | ForEach-Object { $_.DisplayName + " (" + $_.Visibility + ")" }
+                "Public groups found: $($groupDetails -join ', ')"
+            }
+            # Step: Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $null -eq $allGroups -or $allGroups.Count -eq 0
+                Status        = if ($null -eq $allGroups -or $allGroups.Count -eq 0) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
         }
-        else {
-            $groupDetails = $allGroups | ForEach-Object { $_.DisplayName + " (" + $_.Visibility + ")" }
-            $detailsString = $groupDetails -join ', '
-
-            $auditResult.Result = $false
-            $auditResult.Details = "Public groups found: $detailsString"
-            $auditResult.FailureReason = "There are public groups present that are not organizationally managed/approved."
-            $auditResult.Status = "Fail"
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
-
-        $auditResults += $auditResult
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-MeetingChatNoAnonymous.ps1

@@ -1,46 +1,69 @@
 function Test-MeetingChatNoAnonymous {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "8.5.5"
+        Write-Verbose "Running Test-MeetingChatNoAnonymous for $recnum..."
     }
-
     process {
-        # 8.5.5 (L2) Ensure meeting chat does not allow anonymous users
-        # Name doesn't match profile level in benchmarks either.
-
-        # Connect to Teams PowerShell using Connect-MicrosoftTeams
-
-        $CsTeamsMeetingPolicyChat = Get-CsTeamsMeetingPolicy -Identity Global | Select-Object -Property MeetingChatEnabledType
-        $chatAnonDisabled = $CsTeamsMeetingPolicyChat.MeetingChatEnabledType -eq 'EnabledExceptAnonymous'
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "0.0" # Explicitly Not Mapped as per the image provided
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-        $auditResult.Rec = "8.5.5"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $false # Set based on the CIS Controls image
-        $auditResult.IG2 = $false # Set based on the CIS Controls image
-        $auditResult.IG3 = $false # Set based on the CIS Controls image
-        $auditResult.RecDescription = "Ensure meeting chat does not allow anonymous users"
-        $auditResult.Result = $chatAnonDisabled
-        $auditResult.Details = "MeetingChatEnabledType is set to $($CsTeamsMeetingPolicyChat.MeetingChatEnabledType)"
-        $auditResult.FailureReason = if ($chatAnonDisabled) { "N/A" } else { "Meeting chat allows anonymous users" }
-        $auditResult.Status = if ($chatAnonDisabled) { "Pass" } else { "Fail" }
-
-        $auditResults += $auditResult
+        try {
+            # 8.5.5 (L2) Ensure meeting chat does not allow anonymous users
+            #
+            # Validate test for a pass:
+            # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            # - Specific conditions to check:
+            #   - Condition A: The `MeetingChatEnabledType` setting in Teams is set to `EnabledExceptAnonymous`.
+            #   - Condition B: The setting for meeting chat is configured to allow chat for everyone except anonymous users.
+            #   - Condition C: Verification using the Teams Admin Center confirms that the meeting chat settings are configured as recommended.
+            #
+            # Validate test for a fail:
+            # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            # - Specific conditions to check:
+            #   - Condition A: The `MeetingChatEnabledType` setting in Teams is not set to `EnabledExceptAnonymous`.
+            #   - Condition B: The setting for meeting chat allows chat for anonymous users.
+            #   - Condition C: Verification using the Teams Admin Center indicates that the meeting chat settings are not configured as recommended.
+            # Retrieve the Teams meeting policy for meeting chat
+            # $CsTeamsMeetingPolicyChat Mock Object
+            <#
+                $CsTeamsMeetingPolicyChat = [PSCustomObject]@{
+                    MeetingChatEnabledType           = "Enabled"
+                }
+            #>
+            $CsTeamsMeetingPolicyChat = Get-CISMSTeamsOutput -Rec $recnum
+            # Condition A: Check if the MeetingChatEnabledType is set to 'EnabledExceptAnonymous'
+            $chatAnonDisabled = $CsTeamsMeetingPolicyChat.MeetingChatEnabledType -eq 'EnabledExceptAnonymous'
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if ($chatAnonDisabled) {
+                "N/A"
+            }
+            else {
+                "Meeting chat allows anonymous users. User the following command to remediate:`nSet-CsTeamsMeetingPolicy -Identity Global -MeetingChatEnabledType `"EnabledExceptAnonymous`""
+            }
+            $details = "MeetingChatEnabledType is set to $($CsTeamsMeetingPolicyChat.MeetingChatEnabledType)"
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $chatAnonDisabled
+                Status        = if ($chatAnonDisabled) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-ModernAuthExchangeOnline.ps1

@@ -1,54 +1,62 @@
 function Test-ModernAuthExchangeOnline {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Define your parameters here
     )
-
     begin {
-
-        $auditResults = [CISAuditResult]::new()
-        # Initialization code
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Conditions for 6.5.1 (L1) Ensure modern authentication for Exchange Online is enabled
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: Modern authentication for Exchange Online is enabled.
+        #   - Condition B: Exchange Online clients use modern authentication to log in to Microsoft 365 mailboxes.
+        #   - Condition C: Users of older email clients, such as Outlook 2013 and Outlook 2016, are no longer able to authenticate to Exchange using Basic Authentication.
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: Modern authentication for Exchange Online is not enabled.
+        #   - Condition B: Exchange Online clients do not use modern authentication to log in to Microsoft 365 mailboxes.
+        #   - Condition C: Users of older email clients, such as Outlook 2013 and Outlook 2016, are still able to authenticate to Exchange using Basic Authentication.
+        $recnum = "6.5.1"
+        Write-Verbose "Running Test-ModernAuthExchangeOnline for $recnum..."
     }
-
     process {
         try {
-            # Ensuring the ExchangeOnlineManagement module is available
-
-
             # 6.5.1 (L1) Ensure modern authentication for Exchange Online is enabled
-            $orgConfig = Get-OrganizationConfig | Select-Object -Property Name, OAuth2ClientProfileEnabled
-
-            # Create an instance of CISAuditResult and populate it
-
-            $auditResults.CISControlVer = "v8"
-            $auditResults.CISControl = "3.10"
-            $auditResults.CISDescription = "Encrypt Sensitive Data in Transit"
-            $auditResults.IG1 = $false # As per CIS Control v8 mapping for IG1
-            $auditResults.IG2 = $true # As per CIS Control v8 mapping for IG2
-            $auditResults.IG3 = $true # As per CIS Control v8 mapping for IG3
-            $auditResults.ELevel = "E3" # Based on your environment (E3, E5, etc.)
-            $auditResults.ProfileLevel = "L1"
-            $auditResults.Rec = "6.5.1"
-            $auditResults.RecDescription = "Ensure modern authentication for Exchange Online is enabled (Automated)"
-            $auditResults.Result = $orgConfig.OAuth2ClientProfileEnabled
-            $auditResults.Details = $auditResults.Details = $orgConfig.Name + " OAuth2ClientProfileEnabled: " + $orgConfig.OAuth2ClientProfileEnabled
-            $auditResults.FailureReason = if (-not $orgConfig.OAuth2ClientProfileEnabled) { "Modern authentication is disabled" } else { "N/A" }
-            $auditResults.Status = if ($orgConfig.OAuth2ClientProfileEnabled) { "Pass" } else { "Fail" }
-
-
+            # Check modern authentication setting in Exchange Online configuration (Condition A and B)
+            $orgConfig = Get-CISExoOutput -Rec $recnum
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $orgConfig.OAuth2ClientProfileEnabled) {
+                "Modern authentication is disabled"
+            }
+            else {
+                "N/A"
+            }
+            # Details include the current setting (Condition A and B)
+            $details = "OAuth2ClientProfileEnabled: $($orgConfig.OAuth2ClientProfileEnabled) for Organization: $($orgConfig.Name)"
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $orgConfig.OAuth2ClientProfileEnabled
+                Status        = if ($orgConfig.OAuth2ClientProfileEnabled) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
         }
         catch {
-            Write-Error "An error occurred while testing modern authentication for Exchange Online: $_"
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }
-
-
-
-
-

source/tests/Test-ModernAuthSharePoint.ps1

@@ -1,39 +1,68 @@
 function Test-ModernAuthSharePoint {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Define your parameters here
     )
 
     begin {
-        # Initialization code
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
 
-        $auditResult = [CISAuditResult]::new()
+        # Initialization code, if needed
+        $recnum = "7.2.1"
+        Write-Verbose "Running Test-ModernAuthSharePoint for $recnum..."
+        <#
+        # Conditions for 7.2.1 (L1) Ensure modern authentication for SharePoint applications is required
+        ## Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: The setting "Apps that don't use modern authentication" is set to "Block access" in the SharePoint admin center.
+        #   - Condition B: The PowerShell command `Get-SPOTenant | ft LegacyAuthProtocolsEnabled` returns `False`.
+        ## Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: The setting "Apps that don't use modern authentication" is not set to "Block access" in the SharePoint admin center.
+        #   - Condition B: The PowerShell command `Get-SPOTenant | ft LegacyAuthProtocolsEnabled` returns `True`.
+        #>
     }
-
     process {
-        # 7.2.1 (L1) Ensure modern authentication for SharePoint applications is required
-        $SPOTenant = Get-SPOTenant | Select-Object -Property LegacyAuthProtocolsEnabled
-        $modernAuthForSPRequired = -not $SPOTenant.LegacyAuthProtocolsEnabled
-
-        # Populate the auditResult object with the required properties
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "3.10"
-        $auditResult.CISDescription = "Encrypt Sensitive Data in Transit"
-        $auditResult.Rec = "7.2.1"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-        $auditResult.RecDescription = "Modern Authentication for SharePoint Applications"
-        $auditResult.Result = $modernAuthForSPRequired
-        $auditResult.Details = "LegacyAuthProtocolsEnabled: $($SPOTenant.LegacyAuthProtocolsEnabled)"
-        $auditResult.FailureReason = if (-not $modernAuthForSPRequired) { "Legacy authentication protocols are enabled" } else { "N/A" }
-        $auditResult.Status = if ($modernAuthForSPRequired) { "Pass" } else { "Fail" }
+        try {
+            # 7.2.1 (L1) Ensure modern authentication for SharePoint applications is required
+            # $SPOTenant Mock Object
+            <#
+                $SPOTenant = [PSCustomObject]@{
+                    LegacyAuthProtocolsEnabled           = $true
+                }
+            #>
+            $SPOTenant = Get-CISSpoOutput -Rec $recnum
+            $modernAuthForSPRequired = -not $SPOTenant.LegacyAuthProtocolsEnabled
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $modernAuthForSPRequired) {
+                "Legacy authentication protocols are enabled. The following command can be used to disable:`nSet-SPOTenant -LegacyAuthProtocolsEnabled `$false" # Fail Condition B
+            }
+            else {
+                "N/A"
+            }
+            $details = "LegacyAuthProtocolsEnabled: $($SPOTenant.LegacyAuthProtocolsEnabled)" # Details for Condition B
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $modernAuthForSPRequired
+                Status        = if ($modernAuthForSPRequired) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResult
+        # Return the audit result
         return $auditResult
     }
 }

source/tests/Test-NoAnonymousMeetingJoin.ps1

@@ -1,45 +1,68 @@
 function Test-NoAnonymousMeetingJoin {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "8.5.1"
+        Write-Verbose "Running Test-NoAnonymousMeetingJoin for $recnum..."
     }
-
     process {
-        # 8.5.1 (L2) Ensure anonymous users can't join a meeting
-
-        # Connect to Teams PowerShell using Connect-MicrosoftTeams
-
-        $teamsMeetingPolicy = Get-CsTeamsMeetingPolicy -Identity Global
-        $allowAnonymousUsersToJoinMeeting = $teamsMeetingPolicy.AllowAnonymousUsersToJoinMeeting
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "0.0" # The control is Explicitly Not Mapped as per the image provided
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-        $auditResult.Rec = "8.5.1"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L2"
-        $auditResult.IG1 = $false # Set based on the CIS Controls image
-        $auditResult.IG2 = $false # Set based on the CIS Controls image
-        $auditResult.IG3 = $false # Set based on the CIS Controls image
-        $auditResult.RecDescription = "Ensure anonymous users can't join a meeting"
-        $auditResult.Result = -not $allowAnonymousUsersToJoinMeeting
-        $auditResult.Details = "AllowAnonymousUsersToJoinMeeting is set to $allowAnonymousUsersToJoinMeeting"
-        $auditResult.FailureReason = if ($allowAnonymousUsersToJoinMeeting) { "Anonymous users are allowed to join meetings" } else { "N/A" }
-        $auditResult.Status = if (-not $allowAnonymousUsersToJoinMeeting) { "Pass" } else { "Fail" }
-
-        $auditResults += $auditResult
+        try {
+            # 8.5.1 (L2) Ensure anonymous users can't join a meeting
+            #
+            # Validate test for a pass:
+            # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            # - Specific conditions to check:
+            #   - Condition A: `AllowAnonymousUsersToJoinMeeting` is set to `False`.
+            #   - Condition B: Verification using the UI confirms that `Anonymous users can join a meeting` is set to `Off` in the Global meeting policy.
+            #   - Condition C: PowerShell command output indicates that anonymous users are not allowed to join meetings.
+            #
+            # Validate test for a fail:
+            # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            # - Specific conditions to check:
+            #   - Condition A: `AllowAnonymousUsersToJoinMeeting` is not set to `False`.
+            #   - Condition B: Verification using the UI shows that `Anonymous users can join a meeting` is not set to `Off` in the Global meeting policy.
+            #   - Condition C: PowerShell command output indicates that anonymous users are allowed to join meetings.
+            # Connect to Teams PowerShell using Connect-MicrosoftTeams
+            # $teamsMeetingPolicy Mock Object
+            <#
+                $teamsMeetingPolicy = [PSCustomObject]@{
+                    AllowAnonymousUsersToJoinMeeting            = $true
+                }
+            #>
+            $teamsMeetingPolicy = Get-CISMSTeamsOutput -Rec $recnum
+            $allowAnonymousUsersToJoinMeeting = $teamsMeetingPolicy.AllowAnonymousUsersToJoinMeeting
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if ($allowAnonymousUsersToJoinMeeting) {
+                "Anonymous users are allowed to join meetings, remediate with the following command if needed:`nSet-CsTeamsMeetingPolicy -Identity Global -AllowAnonymousUsersToJoinMeeting `$false"
+            }
+            else {
+                "N/A"
+            }
+            $details = "AllowAnonymousUsersToJoinMeeting is set to $allowAnonymousUsersToJoinMeeting"
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = -not $allowAnonymousUsersToJoinMeeting
+                Status        = if (-not $allowAnonymousUsersToJoinMeeting) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-NoAnonymousMeetingStart.ps1

@@ -1,45 +1,63 @@
 function Test-NoAnonymousMeetingStart {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "8.5.2"
+        Write-Verbose "Running Test-NoAnonymousMeetingStart for $recnum..."
     }
-
     process {
-        # 8.5.2 (L1) Ensure anonymous users and dial-in callers can't start a meeting
-
-        # Connect to Teams PowerShell using Connect-MicrosoftTeams
-
-        $CsTeamsMeetingPolicyAnonymous = Get-CsTeamsMeetingPolicy -Identity Global | Select-Object -Property AllowAnonymousUsersToStartMeeting
-        $anonymousStartDisabled = -not $CsTeamsMeetingPolicyAnonymous.AllowAnonymousUsersToStartMeeting
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "0.0" # Explicitly Not Mapped as per the image provided
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-        $auditResult.Rec = "8.5.2"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $false # Set based on the CIS Controls image
-        $auditResult.IG2 = $false # Set based on the CIS Controls image
-        $auditResult.IG3 = $false # Set based on the CIS Controls image
-        $auditResult.RecDescription = "Ensure anonymous users and dial-in callers can't start a meeting"
-        $auditResult.Result = $anonymousStartDisabled
-        $auditResult.Details = "AllowAnonymousUsersToStartMeeting is set to $($CsTeamsMeetingPolicyAnonymous.AllowAnonymousUsersToStartMeeting)"
-        $auditResult.FailureReason = if ($anonymousStartDisabled) { "N/A" } else { "Anonymous users and dial-in callers can start a meeting" }
-        $auditResult.Status = if ($anonymousStartDisabled) { "Pass" } else { "Fail" }
-
-        $auditResults += $auditResult
+        try {
+            # 8.5.2 (L1) Ensure anonymous users and dial-in callers can't start a meeting
+            #
+            # Validate test for a pass:
+            # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            # - Specific conditions to check:
+            #   - Condition A: The `AllowAnonymousUsersToStartMeeting` setting in the Teams admin center is set to `False`.
+            #   - Condition B: The setting for anonymous users and dial-in callers starting a meeting is configured to ensure they must wait in the lobby.
+            #   - Condition C: Verification using the UI confirms that the setting `Anonymous users and dial-in callers can start a meeting` is set to `Off`.
+            #
+            # Validate test for a fail:
+            # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            # - Specific conditions to check:
+            #   - Condition A: The `AllowAnonymousUsersToStartMeeting` setting in the Teams admin center is not set to `False`.
+            #   - Condition B: The setting for anonymous users and dial-in callers starting a meeting allows them to bypass the lobby.
+            #   - Condition C: Verification using the UI indicates that the setting `Anonymous users and dial-in callers can start a meeting` is not set to `Off`.
+            # Connect to Teams PowerShell using Connect-MicrosoftTeams
+            # Retrieve the Teams meeting policy for the global scope and check if anonymous users can start meetings
+            $CsTeamsMeetingPolicyAnonymous = Get-CISMSTeamsOutput -Rec $recnum
+            $anonymousStartDisabled = -not $CsTeamsMeetingPolicyAnonymous.AllowAnonymousUsersToStartMeeting
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if ($anonymousStartDisabled) {
+                "N/A"
+            }
+            else {
+                "Anonymous users and dial-in callers can start a meeting" # Condition A and B
+            }
+            $details = "AllowAnonymousUsersToStartMeeting is set to $($CsTeamsMeetingPolicyAnonymous.AllowAnonymousUsersToStartMeeting)" # Condition C
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $anonymousStartDisabled
+                Status        = if ($anonymousStartDisabled) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-NoWhitelistDomains.ps1

@@ -1,45 +1,69 @@
 function Test-NoWhitelistDomains {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Define your parameters here
     )
-
     begin {
-        # Initialization code
-
-        $auditResult = [CISAuditResult]::new()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "6.2.2"
+        Write-Verbose "Running Test-NoWhitelistDomains for $recnum..."
+        <#
+        Conditions for 6.2.2 (L1) Ensure mail transport rules do not whitelist specific domains (Automated)
+        Validate test for a pass:
+        - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        - Specific conditions to check:
+          - Condition A: No mail transport rules whitelist any specific domains.
+          - Condition B: Verification of mail transport rules using PowerShell shows no domains are whitelisted.
+          - Condition C: Manual review in Exchange Online admin center confirms no whitelisted domains in transport rules.
+        Validate test for a fail:
+        - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        - Specific conditions to check:
+          - Condition A: One or more mail transport rules whitelist specific domains.
+          - Condition B: Verification of mail transport rules using PowerShell shows one or more domains are whitelisted.
+          - Condition C: Manual review in Exchange Online admin center shows whitelisted domains in transport rules.
+        #>
     }
-
     process {
-        # 6.2.2 (L1) Ensure mail transport rules do not whitelist specific domains
-        $whitelistedRules = Get-TransportRule | Where-Object { $_.SetSCL -eq -1 -and $_.SenderDomainIs -ne $null }
-
-        $auditResult.CISControl = "0.0"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-
-        $auditResult.Rec = "6.2.2"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $false
-        $auditResult.IG3 = $false
-        $auditResult.RecDescription = "Ensure mail transport rules do not whitelist specific domains"
-
-        if ($whitelistedRules) {
-            $ruleDetails = $whitelistedRules | ForEach-Object { "{0}: {1}" -f $_.Name, ($_.SenderDomainIs -join ', ') }
-            $auditResult.Result = $false
-            $auditResult.Details = "Whitelisted Rules: $($ruleDetails -join '; ')"
-            $auditResult.FailureReason = "There are transport rules whitelisting specific domains."
-            $auditResult.Status = "Fail"
-        } else {
-            $auditResult.Result = $true
-            $auditResult.Details = "No transport rules whitelisting specific domains found."
-            $auditResult.FailureReason = "N/A"
-            $auditResult.Status = "Pass"
+        try {
+            # 6.2.2 (L1) Ensure mail transport rules do not whitelist specific domains
+            # Retrieve transport rules that whitelist specific domains
+            # Condition A: Checking for transport rules that whitelist specific domains
+            $whitelistedRules = Get-CISExoOutput -Rec $recnum
+            # Prepare failure reasons and details based on compliance
+            # Condition B: Prepare failure reasons based on the presence of whitelisted rules
+            $failureReasons = if ($whitelistedRules) {
+                "There are transport rules whitelisting specific domains."
+            }
+            else {
+                "N/A"
+            }
+            # Condition C: Prepare details about the whitelisted rules if found
+            $details = if ($whitelistedRules) {
+                $ruleDetails = $whitelistedRules | ForEach-Object { "{0}: {1}" -f $_.Name, ($_.SenderDomainIs -join ', ') }
+                "Whitelisted Rules: $($ruleDetails -join '; ')"
+            }
+            else {
+                "No transport rules whitelisting specific domains found."
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = -not $whitelistedRules
+                Status        = if ($whitelistedRules) { "Fail" } else { "Pass" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return auditResult
         return $auditResult

source/tests/Test-NotifyMalwareInternal.ps1

@@ -1,52 +1,93 @@
 function Test-NotifyMalwareInternal {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be added if needed
     )
-
     begin {
-
-        $auditResults = @()
+        <#
+        # Conditions for 2.1.3 (L1) Ensure notifications for internal users sending malware is Enabled
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: Notifications for internal users sending malware are enabled in the Microsoft 365 Security & Compliance Center.
+        #   - Condition B: Using PowerShell, the `NotifyInternal` property in the anti-malware policy is set to `True` and includes at least one valid email address for notifications.
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: Notifications for internal users sending malware are not enabled in the Microsoft 365 Security & Compliance Center.
+        #   - Condition B: Using PowerShell, the `NotifyInternal` property in the anti-malware policy is set to `False` or does not include any valid email addresses for notifications.
+        #>
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "2.1.3"
+        Write-Verbose "Running Test-NotifyMalwareInternal for $recnum..."
     }
-
     process {
-        # Retrieve all 'Custom' malware filter policies and check notification settings
-        $malwareNotifications = Get-MalwareFilterPolicy | Where-Object { $_.RecommendedPolicyType -eq 'Custom' }
-        $policiesToReport = @()
+        try {
+            # 2.1.3 Ensure notifications for internal users sending malware is Enabled
 
-        foreach ($policy in $malwareNotifications) {
-            if ($policy.EnableInternalSenderAdminNotifications -ne $true) {
-                $policiesToReport += "$($policy.Identity): Notifications Disabled"
+            # Retrieve all 'Custom' malware filter policies and check notification settings
+            # $malwareNotifications Mock Object
+            <#
+                $malwareNotifications = @(
+                    [PSCustomObject]@{
+                        Identity = "Default"
+                        EnableInternalSenderAdminNotifications = $true
+                        RecommendedPolicyType = "Custom"
+                    },
+                    [PSCustomObject]@{
+                        Identity = "Anti-malware-Policy"
+                        EnableInternalSenderAdminNotifications = $true
+                        RecommendedPolicyType = "Custom"
+                    }
+                )
+            #>
+            $malwareNotifications = Get-CISExoOutput -Rec $recnum
+            # Condition B: Using PowerShell, the `NotifyInternal` property in the anti-malware policy is set to `True` and includes at least one valid email address for notifications.
+            $policiesToReport = @()
+            foreach ($policy in $malwareNotifications) {
+                if ($policy.EnableInternalSenderAdminNotifications -ne $true) {
+                    $policiesToReport += "$($policy.Identity): Notifications Disabled"
+                }
             }
+            # Determine the result based on the presence of custom policies without notifications
+            $result = $policiesToReport.Count -eq 0
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if ($result) {
+                "N/A"
+            }
+            else {
+                # Condition A: Notifications for internal users sending malware are not enabled in the Microsoft 365 Security & Compliance Center.
+                "Some custom policies do not have notifications for internal users sending malware enabled."
+            }
+            $details = if ($result) {
+                "All custom malware policies have notifications enabled."
+            }
+            else {
+                "Misconfigured Policies: $($policiesToReport -join '`n')"
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $result
+                Status        = if ($result) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
-
-        # Determine the result based on the presence of custom policies without notifications
-        $result = $policiesToReport.Count -eq 0
-        $details = if ($result) { "All custom malware policies have notifications enabled." } else { "Misconfigured Policies: $($policiesToReport -join ', ')" }
-        $failureReason = if ($result) { "N/A" } else { "Some custom policies do not have notifications for internal users sending malware enabled." }
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.Status = if ($result) { "Pass" } else { "Fail" }
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.Rec = "2.1.3"
-        $auditResult.RecDescription = "Ensure notifications for internal users sending malware is Enabled"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "17.5"
-        $auditResult.CISDescription = "Assign Key Roles and Responsibilities"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-        $auditResult.Result = $result
-        $auditResult.Details = $details
-        $auditResult.FailureReason = $failureReason
-
-        $auditResults += $auditResult
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-OneDriveContentRestrictions.ps1

@@ -1,39 +1,73 @@
 function Test-OneDriveContentRestrictions {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Define your parameters here
     )
-
     begin {
-        # Initialization code
-
-        $auditResult = [CISAuditResult]::new()
-    }
-
-    process {
         # 7.2.4 (L2) Ensure OneDrive content sharing is restricted
-        $SPOTenant = Get-SPOTenant | Select-Object OneDriveSharingCapability
-        $isOneDriveSharingRestricted = $SPOTenant.OneDriveSharingCapability -eq 'Disabled'
-
-        # Populate the auditResult object with the required properties
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "3.3"
-        $auditResult.CISDescription = "Configure Data Access Control Lists"
-
-        $auditResult.Rec = "7.2.4"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L2"
-        $auditResult.IG1 = $true
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-        $auditResult.RecDescription = "Ensure OneDrive content sharing is restricted"
-
-        $auditResult.Result = $isOneDriveSharingRestricted
-        $auditResult.Details = "OneDriveSharingCapability: $($SPOTenant.OneDriveSharingCapability)"
-        $auditResult.FailureReason = if (-not $isOneDriveSharingRestricted) { "OneDrive content sharing is not restricted to 'Disabled'. Current setting: $($SPOTenant.OneDriveSharingCapability)" } else { "N/A" }
-        $auditResult.Status = if ($isOneDriveSharingRestricted) { "Pass" } else { "Fail" }
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: The OneDriveSharingCapability setting is configured to "Disabled" using the PowerShell cmdlet `Get-SPOTenant | fl OneDriveSharingCapability`.
+        #   - Condition B: The OneDriveSharingCapability is set to "Only people in your organization" in the SharePoint admin center under Policies > Sharing > OneDrive.
+        #   - Condition C: OneDrive content sharing is not more permissive than SharePoint content sharing.
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: The OneDriveSharingCapability setting is not configured to "Disabled" using the PowerShell cmdlet `Get-SPOTenant | fl OneDriveSharingCapability`.
+        #   - Condition B: The OneDriveSharingCapability is not set to "Only people in your organization" in the SharePoint admin center under Policies > Sharing > OneDrive.
+        #   - Condition C: OneDrive content sharing is more permissive than SharePoint content sharing.
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "7.2.4"
+        Write-Verbose "Running Test-OneDriveContentRestrictions for $recnum..."
+    }
+    process {
+        try {
+            # 7.2.4 (L2) Ensure OneDrive content sharing is restricted
+            # Retrieve OneDrive sharing capability settings
+            # $SPOTenant Mock Object
+            <#
+                $SPOTenant = [PSCustomObject]@{
+                    OneDriveSharingCapability           = "ExternalUserAndGuestSharing"
+                }
+            #>
+            $SPOTenant = Get-CISSpoOutput -Rec $recnum
+            $isOneDriveSharingRestricted = $SPOTenant.OneDriveSharingCapability -eq 'Disabled'
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $isOneDriveSharingRestricted) {
+                "OneDrive content sharing is not restricted to 'Disabled'. To remediate this setting, use the Set-SPOTenant command.`n`n" + `
+                "Set-SPOTenant -OneDriveSharingCapability Disabled"
+            }
+            else {
+                "N/A"
+            }
+            $details = if ($isOneDriveSharingRestricted) {
+                "OneDrive content sharing is restricted."
+            }
+            else {
+                "OneDriveSharingCapability: $($SPOTenant.OneDriveSharingCapability)"
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $isOneDriveSharingRestricted
+                Status        = if ($isOneDriveSharingRestricted) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
         # Return auditResult
         return $auditResult

source/tests/Test-OneDriveSyncRestrictions.ps1

@@ -1,39 +1,70 @@
 function Test-OneDriveSyncRestrictions {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Define your parameters here
     )
-
     begin {
-        # Initialization code
-
-        $auditResult = [CISAuditResult]::new()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "7.3.2"
+        Write-Verbose "Running Test-OneDriveSyncRestrictions for $recnum..."
     }
-
     process {
-        # 7.3.2 (L2) Ensure OneDrive sync is restricted for unmanaged devices
-        $SPOTenantSyncClientRestriction = Get-SPOTenantSyncClientRestriction | Select-Object TenantRestrictionEnabled, AllowedDomainList
-        $isSyncRestricted = $SPOTenantSyncClientRestriction.TenantRestrictionEnabled -and $SPOTenantSyncClientRestriction.AllowedDomainList
-
-        # Populate the auditResult object with the required properties
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "0.0"
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-
-        $auditResult.Rec = "7.3.2"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L2"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $false
-        $auditResult.IG3 = $false
-        $auditResult.RecDescription = "Ensure OneDrive sync is restricted for unmanaged devices"
-
-        $auditResult.Result = $isSyncRestricted
-        $auditResult.Details = "TenantRestrictionEnabled: $($SPOTenantSyncClientRestriction.TenantRestrictionEnabled); AllowedDomainList: $($SPOTenantSyncClientRestriction.AllowedDomainList -join ', ')"
-        $auditResult.FailureReason = if (-not $isSyncRestricted) { "OneDrive sync is not restricted to managed devices. TenantRestrictionEnabled should be True and AllowedDomainList should contain trusted domains GUIDs." } else { "N/A" }
-        $auditResult.Status = if ($isSyncRestricted) { "Pass" } else { "Fail" }
+        try {
+            # 7.3.2 (L2) Ensure OneDrive sync is restricted for unmanaged devices
+            #
+            # Validate test for a pass:
+            # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            # - Specific conditions to check:
+            #   - Condition A: Verify that "Allow syncing only on computers joined to specific domains" is enabled.
+            #   - Condition B: Check that "TenantRestrictionEnabled" is set to True.
+            #   - Condition C: Ensure that "AllowedDomainList" contains the trusted domain GUIDs from the on-premises environment.
+            #
+            # Validate test for a fail:
+            # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            # - Specific conditions to check:
+            #   - Condition A: "Allow syncing only on computers joined to specific domains" is not enabled.
+            #   - Condition B: "TenantRestrictionEnabled" is set to False.
+            #   - Condition C: "AllowedDomainList" does not contain the trusted domain GUIDs from the on-premises environment.
+            # Retrieve OneDrive sync client restriction settings
+            $SPOTenantSyncClientRestriction = Get-CISSpoOutput -Rec $recnum
+            $isSyncRestricted = $SPOTenantSyncClientRestriction.TenantRestrictionEnabled -and $SPOTenantSyncClientRestriction.AllowedDomainList
+            # Condition A: Check if TenantRestrictionEnabled is True
+            # Condition B: Ensure AllowedDomainList contains trusted domains GUIDs
+            $failureReasons = if (-not $isSyncRestricted) {
+                "OneDrive sync is not restricted to managed devices. For hybrid devices, TenantRestrictionEnabled should be True and AllowedDomainList should contain trusted domains GUIDs.`n" + `
+                "To remediate this setting, edit and use the Set-SPOTenantSyncClientRestriction command below:`n" + `
+                "Set-SPOTenantSyncClientRestriction -TenantRestrictionEnabled `$true -AllowedDomainList `"<GUID1>`",`"<GUID2>`"`n`n" + `
+                "Note: Utilize the -BlockMacSync:`$true parameter if you are not using conditional access to ensure Macs cannot sync."
+            }
+            else {
+                "N/A"
+            }
+            # Condition C: Prepare details based on whether sync is restricted
+            $details = if ($isSyncRestricted) {
+                "OneDrive sync is restricted for unmanaged devices."
+            }
+            else {
+                "TenantRestrictionEnabled: $($SPOTenantSyncClientRestriction.TenantRestrictionEnabled); AllowedDomainList: $($SPOTenantSyncClientRestriction.AllowedDomainList -join ', ')"
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $isSyncRestricted
+                Status        = if ($isSyncRestricted) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
         # Return auditResult
         return $auditResult

source/tests/Test-OrgOnlyBypassLobby.ps1

@@ -1,45 +1,69 @@
 function Test-OrgOnlyBypassLobby {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "8.5.3"
+        Write-Verbose "Running Test-OrgOnlyBypassLobby for $recnum..."
     }
-
     process {
-        # 8.5.3 (L1) Ensure only people in my org can bypass the lobby
-
-        # Connect to Teams PowerShell using Connect-MicrosoftTeams
-
-        $CsTeamsMeetingPolicyLobby = Get-CsTeamsMeetingPolicy -Identity Global | Select-Object -Property AutoAdmittedUsers
-        $lobbyBypassRestricted = $CsTeamsMeetingPolicyLobby.AutoAdmittedUsers -eq 'EveryoneInCompanyExcludingGuests'
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "6.8"
-        $auditResult.CISDescription = "Define and Maintain Role-Based Access Control"
-        $auditResult.Rec = "8.5.3"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $false # Set based on the CIS Controls image
-        $auditResult.IG2 = $false # Set based on the CIS Controls image
-        $auditResult.IG3 = $true # Set based on the CIS Controls image
-        $auditResult.RecDescription = "Ensure only people in my org can bypass the lobby"
-        $auditResult.Result = $lobbyBypassRestricted
-        $auditResult.Details = "AutoAdmittedUsers is set to $($CsTeamsMeetingPolicyLobby.AutoAdmittedUsers)"
-        $auditResult.FailureReason = if ($lobbyBypassRestricted) { "N/A" } else { "External participants can bypass the lobby" }
-        $auditResult.Status = if ($lobbyBypassRestricted) { "Pass" } else { "Fail" }
-
-        $auditResults += $auditResult
+        try {
+            # 8.5.3 (L1) Ensure only people in my org can bypass the lobby
+            #
+            # Validate test for a pass:
+            # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            # - Specific conditions to check:
+            #   - Condition A: The `AutoAdmittedUsers` setting in the Teams meeting policy is set to `EveryoneInCompanyExcludingGuests`.
+            #   - Condition B: The setting for "Who can bypass the lobby" is configured to "People in my org" using the UI.
+            #   - Condition C: Verification using the Microsoft Teams admin center confirms that the meeting join & lobby settings are configured as recommended.
+            #
+            # Validate test for a fail:
+            # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            # - Specific conditions to check:
+            #   - Condition A: The `AutoAdmittedUsers` setting in the Teams meeting policy is not set to `EveryoneInCompanyExcludingGuests`.
+            #   - Condition B: The setting for "Who can bypass the lobby" is not configured to "People in my org" using the UI.
+            #   - Condition C: Verification using the Microsoft Teams admin center indicates that the meeting join & lobby settings are not configured as recommended.
+            # Connect to Teams PowerShell using Connect-MicrosoftTeams
+            # Retrieve the Teams meeting policy for lobby bypass settings
+            $CsTeamsMeetingPolicyLobby = Get-CISMSTeamsOutput -Rec $recnum
+            $lobbyBypassRestricted = $CsTeamsMeetingPolicyLobby.AutoAdmittedUsers -eq 'EveryoneInCompanyExcludingGuests'
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $lobbyBypassRestricted) {
+                # Condition C: Verification using the Microsoft Teams admin center indicates that the meeting join & lobby settings are not configured as recommended.
+                "AutoAdmittedUsers is set to $($CsTeamsMeetingPolicyLobby.AutoAdmittedUsers)"
+            }else {
+                "N/A"
+            }
+            $details = if ($lobbyBypassRestricted) {
+                # Condition B: The setting for "Who can bypass the lobby" is configured to "People in my org" using the UI.
+                "Only people in the organization can bypass the lobby."
+            }else {
+                # Condition A: The `AutoAdmittedUsers` setting in the Teams meeting policy is not set to `EveryoneInCompanyExcludingGuests`.
+                "AutoAdmittedUsers is not set to EveryoneInCompanyExcludingGuests"
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $lobbyBypassRestricted
+                Status        = if ($lobbyBypassRestricted) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-OrganizersPresent.ps1

@@ -1,45 +1,73 @@
 function Test-OrganizersPresent {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "8.5.6"
+        Write-Verbose "Running Test-OrganizersPresent for $recnum..."
     }
-
     process {
-        # 8.5.6 (L2) Ensure only organizers and co-organizers can present
-
-        # Connect to Teams PowerShell using Connect-MicrosoftTeams
-
-        $CsTeamsMeetingPolicyPresenters = Get-CsTeamsMeetingPolicy -Identity Global | Select-Object -Property DesignatedPresenterRoleMode
-        $presenterRoleRestricted = $CsTeamsMeetingPolicyPresenters.DesignatedPresenterRoleMode -eq 'OrganizerOnlyUserOverride'
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "0.0" # Explicitly Not Mapped as per the image provided
-        $auditResult.CISDescription = "Explicitly Not Mapped"
-        $auditResult.Rec = "8.5.6"
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.IG1 = $false # Set based on the CIS Controls image
-        $auditResult.IG2 = $false # Set based on the CIS Controls image
-        $auditResult.IG3 = $false # Set based on the CIS Controls image
-        $auditResult.RecDescription = "Ensure only organizers and co-organizers can present"
-        $auditResult.Result = $presenterRoleRestricted
-        $auditResult.Details = "DesignatedPresenterRoleMode is set to $($CsTeamsMeetingPolicyPresenters.DesignatedPresenterRoleMode)"
-        $auditResult.FailureReason = if ($presenterRoleRestricted) { "N/A" } else { "Others besides organizers and co-organizers can present" }
-        $auditResult.Status = if ($presenterRoleRestricted) { "Pass" } else { "Fail" }
-
-        $auditResults += $auditResult
+        try {
+            # 8.5.6 (L2) Ensure only organizers and co-organizers can present
+            #
+            # Validate test for a pass:
+            # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+            # - Specific conditions to check:
+            #   - Condition A: The `DesignatedPresenterRoleMode` setting in the Teams meeting policy is set to `OrganizerOnlyUserOverride`.
+            #   - Condition B: Verification using the Teams admin center confirms that the setting "Who can present" is configured to "Only organizers and co-organizers".
+            #   - Condition C: Verification using PowerShell confirms that the `DesignatedPresenterRoleMode` is set to `OrganizerOnlyUserOverride`.
+            #
+            # Validate test for a fail:
+            # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+            # - Specific conditions to check:
+            #   - Condition A: The `DesignatedPresenterRoleMode` setting in the Teams meeting policy is not set to `OrganizerOnlyUserOverride`.
+            #   - Condition B: Verification using the Teams admin center indicates that the setting "Who can present" is not configured to "Only organizers and co-organizers".
+            #   - Condition C: Verification using PowerShell indicates that the `DesignatedPresenterRoleMode` is not set to `OrganizerOnlyUserOverride`.
+            # Retrieve the Teams meeting policy for presenters
+            # $CsTeamsMeetingPolicyPresenters Mock Object
+            <#
+                $CsTeamsMeetingPolicyPresenters = [PSCustomObject]@{
+                    DesignatedPresenterRoleMode           = "Enabled"
+                }
+            #>
+            $CsTeamsMeetingPolicyPresenters = Get-CISMSTeamsOutput -Rec $recnum
+            $presenterRoleRestricted = $CsTeamsMeetingPolicyPresenters.DesignatedPresenterRoleMode -eq 'OrganizerOnlyUserOverride'
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $presenterRoleRestricted) {
+                "Others besides organizers and co-organizers can present. Use the following command to remediate:`nSet-CsTeamsMeetingPolicy -Identity Global -DesignatedPresenterRoleMode `"OrganizerOnlyUserOverride`""
+            }
+            else {
+                "N/A"
+            }
+            $details = if ($presenterRoleRestricted) {
+                "Only organizers and co-organizers can present."
+            }
+            else {
+                "DesignatedPresenterRoleMode is set to $($CsTeamsMeetingPolicyPresenters.DesignatedPresenterRoleMode)"
+            }
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $presenterRoleRestricted
+                Status        = if ($presenterRoleRestricted) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
 }

source/tests/Test-PasswordHashSync.ps1

@@ -1,43 +1,63 @@
 function Test-PasswordHashSync {
     [CmdletBinding()]
+    [OutputType([CISAuditResult])]
     param (
+        # Aligned
         # Parameters can be added if needed
     )
-
     begin {
-        # Dot source the class script
-
-        $auditResults = @()
+        # Conditions for 5.1.8.1 (L1) Ensure password hash sync is enabled for hybrid deployments
+        #
+        # Validate test for a pass:
+        # - Confirm that the automated test results align with the manual audit steps outlined in the CIS benchmark.
+        # - Specific conditions to check:
+        #   - Condition A: Password hash sync is enabled in the Azure AD Connect tool on the on-premises server.
+        #   - Condition B: Password hash sync is verified as enabled in the Azure AD Connect Sync section in the Microsoft Entra admin center.
+        #   - Condition C: Using Microsoft Graph PowerShell, the verification command returns the expected result indicating that password sync is enabled for the on-premises AD.
+        #
+        # Validate test for a fail:
+        # - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        # - Specific conditions to check:
+        #   - Condition A: Password hash sync is not enabled in the Azure AD Connect tool on the on-premises server.
+        #   - Condition B: Password hash sync is not verified as enabled in the Azure AD Connect Sync section in the Microsoft Entra admin center.
+        #   - Condition C: Using Microsoft Graph PowerShell, the verification command returns no result indicating that password sync is not enabled for the on-premises AD.
+        # Dot source the class script if necessary
+        #. .\source\Classes\CISAuditResult.ps1
+        # Initialization code, if needed
+        $recnum = "5.1.8.1"
+        Write-Verbose "Starting Test-PasswordHashSync with Rec: $recnum"
     }
-
     process {
-        # 5.1.8.1 (L1) Ensure password hash sync is enabled for hybrid deployments
-        # Pass if OnPremisesSyncEnabled is True. Fail otherwise.
-        $passwordHashSync = Get-MgOrganization | Select-Object OnPremisesSyncEnabled
-        $hashSyncResult = $passwordHashSync.OnPremisesSyncEnabled
-
-        # Create an instance of CISAuditResult and populate it
-        $auditResult = [CISAuditResult]::new()
-        $auditResult.Status = if ($hashSyncResult) { "Pass" } else { "Fail" }
-        $auditResult.ELevel = "E3"
-        $auditResult.ProfileLevel = "L1"
-        $auditResult.Rec = "5.1.8.1"
-        $auditResult.RecDescription = "Ensure password hash sync is enabled for hybrid deployments"
-        $auditResult.CISControlVer = "v8"
-        $auditResult.CISControl = "6.7"
-        $auditResult.CISDescription = "Centralize Access Control"
-        $auditResult.IG1 = $false
-        $auditResult.IG2 = $true
-        $auditResult.IG3 = $true
-        $auditResult.Result = $hashSyncResult
-        $auditResult.Details = "OnPremisesSyncEnabled: $($passwordHashSync.OnPremisesSyncEnabled)"
-        $auditResult.FailureReason = if (-not $hashSyncResult) { "Password hash sync for hybrid deployments is not enabled" } else { "N/A" }
-
-        $auditResults += $auditResult
+        try {
+            # 5.1.8.1 (L1) Ensure password hash sync is enabled for hybrid deployments
+            # Retrieve password hash sync status (Condition A and C)
+            $passwordHashSync = Get-CISMgOutput -Rec $recnum
+            $hashSyncResult = $passwordHashSync
+            # Prepare failure reasons and details based on compliance
+            $failureReasons = if (-not $hashSyncResult) {
+                "Password hash sync for hybrid deployments is not enabled"
+            }
+            else {
+                "N/A"
+            }
+            $details = "OnPremisesSyncEnabled: $($passwordHashSync)"
+            # Create and populate the CISAuditResult object
+            $params = @{
+                Rec           = $recnum
+                Result        = $hashSyncResult
+                Status        = if ($hashSyncResult) { "Pass" } else { "Fail" }
+                Details       = $details
+                FailureReason = $failureReasons
+            }
+            $auditResult = Initialize-CISAuditResult @params
+        }
+        catch {
+            $LastError = $_
+            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+        }
     }
-
     end {
-        # Return auditResults
-        return $auditResults
+        # Return the audit result
+        return $auditResult
     }
-}
+}