Merge pull request #137 from CriticalSolutionsNetwork/132-formatting-microsoft-graph

fix: MgGraph commands formatting

CHANGELOG.md

@@ -6,6 +6,67 @@ The format is based on and uses the types of changes according to [Keep a Change
 
 ### 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.

help/Export-M365SecurityAuditTable.md

@@ -0,0 +1,202 @@
+---
+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>
+ [<CommonParameters>]
+```
+
+### ExportAllResultsFromAuditResults
+```
+Export-M365SecurityAuditTable [-AuditResults] <CISAuditResult[]> [-ExportAllTests] -ExportPath <String>
+ [-ExportOriginalTests] [-ExportToExcel] [<CommonParameters>]
+```
+
+### OutputObjectFromCsvSingle
+```
+Export-M365SecurityAuditTable [-CsvPath] <String> [-OutputTestNumber] <String> [<CommonParameters>]
+```
+
+### ExportAllResultsFromCsv
+```
+Export-M365SecurityAuditTable [-CsvPath] <String> [-ExportAllTests] -ExportPath <String> [-ExportOriginalTests]
+ [-ExportToExcel] [<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
+```
+
+### -ExportAllTests
+Switch to export all test results.
+
+```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: True
+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
+```
+
+### 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[]], [string]
+## OUTPUTS
+
+### [PSCustomObject]
+## NOTES
+
+## RELATED LINKS
+
+[https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Export-M365SecurityAuditTable](https://criticalsolutionsnetwork.github.io/M365FoundationsCISReport/#Export-M365SecurityAuditTable)
+

help/Get-AdminRoleUserLicense.md

@@ -0,0 +1,74 @@
+---
+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] [<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
+```
+
+### 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,93 @@
+---
+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] [<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
+```
+
+### 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,163 @@
+---
+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] [-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
+```
+
+### 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,450 @@
+---
+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] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+### ELevelFilter
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>] -ELevel <String>
+ -ProfileLevel <String> [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>]
+ [-DoNotConnect] [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections] [-WhatIf] [-Confirm]
+ [<CommonParameters>]
+```
+
+### IG1Filter
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>] [-IncludeIG1]
+ [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>] [-DoNotConnect]
+ [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+### IG2Filter
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>] [-IncludeIG2]
+ [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>] [-DoNotConnect]
+ [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+### IG3Filter
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>] [-IncludeIG3]
+ [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>] [-DoNotConnect]
+ [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+### RecFilter
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>] -IncludeRecommendation <String[]>
+ [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>] [-DoNotConnect]
+ [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections] [-WhatIf] [-Confirm] [<CommonParameters>]
+```
+
+### SkipRecFilter
+```
+Invoke-M365SecurityAudit [-TenantAdminUrl <String>] [-DomainName <String>] -SkipRecommendation <String[]>
+ [-ApprovedCloudStorageProviders <String[]>] [-ApprovedFederatedDomains <String[]>] [-DoNotConnect]
+ [-DoNotDisconnect] [-NoModuleCheck] [-DoNotConfirmConnections] [-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
+```
+
+### -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
+```
+
+### 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,34 @@
+---
+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.
+
+### [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/Remove-RowsWithEmptyCSVStatus.md

@@ -0,0 +1,73 @@
+---
+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> [<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
+```
+
+### 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,102 @@
+---
+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>]
+ [<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
+```
+
+### 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,59 @@
+# 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"
+
+# Example 2: Exporting a security audit table to a CSV file
+Export-M365SecurityAuditTable -ExportAllTests -AuditResults $auditResults -ExportPath "C:\temp" -ExportOriginalTests
+
+# 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'
+```
+
+# 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/Build-Help.ps1

@@ -4,7 +4,7 @@ Import-Module .\output\module\M365FoundationsCISReport\*\*.psd1
 
 
 <#
-    $ver = "v0.1.12"
+    $ver = "v0.1.18"
     git checkout main
     git pull origin main
     git tag -a $ver -m "Release version $ver refactor Update"
@@ -13,3 +13,52 @@ Import-Module .\output\module\M365FoundationsCISReport\*\*.psd1
     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

source/Private/Get-CISExoOutput.ps1

@@ -52,18 +52,105 @@ function Get-CISExoOutput {
                 # Test-BlockSharedMailboxSignIn.ps1
                 $MBX = Get-EXOMailbox -RecipientTypeDetails SharedMailbox
                 # [object[]]
-                return $MBX
+                # $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.3b' {
+                # $mailboxes Mock Object
+                <#
+                    $mailboxes = @(
+                        [PSCustomObject]@{
+                            UserPrincipalName = "SMBuser1@domain.com"
+                            ExternalDirectoryObjectId = "123e4567-e89b-12d3-a456-426614174000"
+                            PrimarySmtpAddress = "SMBuser1@domain.com"
+                            PublishEnabled       = $False
+                            PublishedCalendarUrl = "https://example.com/calendar/smbuser1"
+                        },
+                        [PSCustomObject]@{
+                            UserPrincipalName = "SMBuser2@domain.com"
+                            ExternalDirectoryObjectId = "987e6543-21ba-12d3-a456-426614174000"
+                            PrimarySmtpAddress = "SMBuser2@domain.com"
+                            PublishEnabled       = $False
+                            PublishedCalendarUrl = "https://example.com/calendar/smbuser2"
+                        },
+                        [PSCustomObject]@{
+                            UserPrincipalName = "SMBuser3@domain.com"
+                            ExternalDirectoryObjectId = "abcddcba-98fe-76dc-a456-426614174000"
+                            PrimarySmtpAddress = "SMBuser3@domain.com"
+                            PublishEnabled       = $False
+                            PublishedCalendarUrl = "https://example.com/calendar/smbuser3"
+                        }
+                    )
+                #>
+                $mailboxes = Get-Mailbox -ResultSize Unlimited
+                $results = foreach ($mailbox in $mailboxes) {
+                    # Get the name of the default calendar folder (depends on the mailbox's language)
+                    # Return single string Ex: return "Calendar" x 3 in array
+                    $calendarFolder = [string](Get-EXOMailboxFolderStatistics $mailbox.PrimarySmtpAddress -Folderscope Calendar | Where-Object { $_.FolderType -eq 'Calendar' }).Name
+                    Write-Verbose "Calendar folder for $($mailbox.PrimarySmtpAddress): $calendarFolder"
+                    # Get users calendar folder settings for their default Calendar folder
+                    # calendar has the format identity:\<calendar folder name>
+                    $calendar = Get-MailboxCalendarFolder -Identity "$($mailbox.PrimarySmtpAddress):\$calendarFolder"
+                    #Write-Host "Calendar object for $($mailbox.PrimarySmtpAddress): $calendar"
+                    Write-Verbose "Calendar publishing enabled: $($calendar.PublishEnabled)"
+                    # Check if calendar publishing is enabled and create a custom object
+                    if ($calendar.PublishEnabled) {
+                        [PSCustomObject]@{
+                            PrimarySmtpAddress   = $mailbox.PrimarySmtpAddress
+                            CalendarFolder       = $calendarFolder
+                            PublishEnabled       = $calendar.PublishEnabled
+                            PublishedCalendarUrl = $calendar.PublishedCalendarUrl
+                        }
+                    }
+                }
+                $calendarDetails = @()
+                foreach ($calendar in $results) {
+                    $calendarDetails += "Calendar: $($calendar.PrimarySmtpAddress); URL: $($calendar.PublishedCalendarUrl)"
+                }
+                return $calendarDetails
+            }
             '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]
@@ -74,12 +161,41 @@ function Get-CISExoOutput {
                 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 = Get-SafeLinksPolicy -Identity $policy.Name
+                        $policyDetails = $policy #Get-SafeLinksPolicy -Identity $policy.Name
                         # Check each required property and record failures
                         # Condition A: Checking policy settings
                         $failures = @()
@@ -106,6 +222,12 @@ function Get-CISExoOutput {
                 # 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]
@@ -115,6 +237,21 @@ function Get-CISExoOutput {
                 # 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
@@ -124,6 +261,18 @@ function Get-CISExoOutput {
                 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 }
                     # [object[]]
                     return $safeAttachmentPolicies
@@ -139,6 +288,17 @@ function Get-CISExoOutput {
                     # 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
@@ -153,13 +313,82 @@ function Get-CISExoOutput {
             }
             '2.1.6' {
                 # Test-SpamPolicyAdminNotify.ps1
-                # Retrieve the default hosted outbound spam filter policy
-                $hostedOutboundSpamFilterPolicy = Get-HostedOutboundSpamFilterPolicy | Where-Object { $_.IsDefault -eq $true }
-                return $hostedOutboundSpamFilterPolicy
+                # 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
-                # Condition A: Ensure that an anti-phishing policy has been created
+                <#
+                    $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
             }
@@ -284,7 +513,20 @@ function Get-CISExoOutput {
                 # 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 = Get-ReportSubmissionPolicy | Select-Object -Property ReportJunkToCustomizedAddress, ReportNotJunkToCustomizedAddress, ReportPhishToCustomizedAddress, ReportChatMessageToCustomizedAddressEnabled
+                # $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" }

source/Private/Get-CISMSTeamsOutput.ps1

@@ -49,6 +49,7 @@ function Get-CISMSTeamsOutput {
 
                 # 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
             }
@@ -91,9 +92,29 @@ function Get-CISMSTeamsOutput {
                 #   - 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
             }
@@ -114,9 +135,13 @@ function Get-CISMSTeamsOutput {
                 #   - 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
             }
@@ -137,9 +162,13 @@ function Get-CISMSTeamsOutput {
                 #   - 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
@@ -161,10 +190,14 @@ function Get-CISMSTeamsOutput {
                 #   - 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
             }
@@ -185,8 +218,13 @@ function Get-CISMSTeamsOutput {
                 #   - 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
             }
@@ -207,8 +245,13 @@ function Get-CISMSTeamsOutput {
                 #   - 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
             }
@@ -229,8 +272,13 @@ function Get-CISMSTeamsOutput {
                 #   - 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
             }
@@ -251,17 +299,27 @@ function Get-CISMSTeamsOutput {
                 #   - 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
             }

source/Private/Get-CISMgOutput.ps1

@@ -42,10 +42,12 @@ function Get-CISMgOutput {
         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
@@ -53,6 +55,7 @@ function Get-CISMgOutput {
                 return $globalAdmins
             }
             '1.2.1' {
+                # Test-ManagedApprovedPublicGroups
                 $allGroups = Get-MgGroup -All | Where-Object { $_.Visibility -eq "Public" } | Select-Object DisplayName, Visibility
                 return $allGroups
             }
@@ -67,16 +70,19 @@ function Get-CISMgOutput {
                 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 }
@@ -89,6 +95,7 @@ function Get-CISMgOutput {
                 }
             }
             '6.1.3' {
+                # Test-MailboxAuditingE5
                 $tenantSkus = Get-MgSubscribedSku -All
                 $e5SkuPartNumber = "SPE_E5"
                 $founde5Sku = $tenantSkus | Where-Object { $_.SkuPartNumber -eq $e5SkuPartNumber }

source/Private/Get-ExceededLengthResultDetail.ps1

@@ -9,7 +9,7 @@ function Get-ExceededLengthResultDetail {
         [Parameter(Mandatory = $true, ParameterSetName = 'ReturnExceedingTests')]
         [string[]]$TestNumbersToCheck,
 
-        [Parameter(Mandatory = $true, ParameterSetName = 'UpdateArray')]
+        [Parameter(Mandatory = $false, ParameterSetName = 'UpdateArray')]
         [string[]]$ExportedTests,
 
         [Parameter(Mandatory = $true, ParameterSetName = 'ReturnExceedingTests')]

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/Invoke-TestFunction.ps1

@@ -3,9 +3,12 @@ function Invoke-TestFunction {
     param (
         [Parameter(Mandatory = $true)]
         [PSObject]$FunctionFile,
-
         [Parameter(Mandatory = $false)]
-        [string]$DomainName
+        [string]$DomainName,
+        [Parameter(Mandatory = $false)]
+        [string[]]$ApprovedCloudStorageProviders,
+        [Parameter(Mandatory = $false)]
+        [string[]]$ApprovedFederatedDomains
     )
 
     $functionName = $FunctionFile.BaseName
@@ -16,7 +19,12 @@ function Invoke-TestFunction {
     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 {

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/Public/Export-M365SecurityAuditTable.ps1

@@ -61,16 +61,16 @@ function Export-M365SecurityAuditTable {
         [ValidateSet("1.1.1", "1.3.1", "6.1.2", "6.1.3", "7.3.4")]
         [string]$OutputTestNumber,
 
-        [Parameter(Mandatory = $true, Position = 0, ParameterSetName = "ExportAllResultsFromAuditResults")]
-        [Parameter(Mandatory = $true, Position = 0, ParameterSetName = "ExportAllResultsFromCsv")]
+        [Parameter(Mandatory = $false, Position = 0, ParameterSetName = "ExportAllResultsFromAuditResults")]
+        [Parameter(Mandatory = $false, Position = 0, ParameterSetName = "ExportAllResultsFromCsv")]
         [switch]$ExportAllTests,
 
         [Parameter(Mandatory = $true, ParameterSetName = "ExportAllResultsFromAuditResults")]
         [Parameter(Mandatory = $true, ParameterSetName = "ExportAllResultsFromCsv")]
         [string]$ExportPath,
 
-        [Parameter(Mandatory = $false, ParameterSetName = "ExportAllResultsFromAuditResults")]
-        [Parameter(Mandatory = $false, ParameterSetName = "ExportAllResultsFromCsv")]
+        [Parameter(Mandatory = $true, ParameterSetName = "ExportAllResultsFromAuditResults")]
+        [Parameter(Mandatory = $true, ParameterSetName = "ExportAllResultsFromCsv")]
         [switch]$ExportOriginalTests,
 
         [Parameter(Mandatory = $false, ParameterSetName = "ExportAllResultsFromAuditResults")]
@@ -191,7 +191,7 @@ function Export-M365SecurityAuditTable {
         }
         else {
             if ($ExportOriginalTests) {
-                Write-Information "No specified tests were included in the export other than the full audit results." -InformationAction Continue
+                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" -InformationAction Continue
             }
             else {
                 Write-Information "No specified tests were included in the export." -InformationAction Continue

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

@@ -5,7 +5,7 @@
         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.
     .PARAMETER TenantAdminUrl
         The URL of the tenant admin. If not specified, none of the SharePoint Online tests will run.
-    .PARAMETER M365DomainForPWPolicyTest
+    .PARAMETER 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.
     .PARAMETER ELevel
         Specifies the E-Level (E3 or E5) for the audit. This parameter is optional and can be combined with the ProfileLevel parameter.
@@ -21,6 +21,10 @@
         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.
+    .PARAMETER ApprovedCloudStorageProviders
+        Specifies the approved cloud storage providers for the audit. Accepts an array of cloud storage provider names.
+    .PARAMETER ApprovedFederatedDomains
+        Specifies the approved federated domains for the audit test 8.2.1. Accepts an array of allowed domain names.
     .PARAMETER DoNotConnect
         If specified, the cmdlet will not establish a connection to Microsoft 365 services.
     .PARAMETER DoNotDisconnect
@@ -46,7 +50,7 @@
                         user2@domain.com| Global Administrator   | Hybrid       | AAD_PREMIUM, AAD_PREMIUM_P2
         FailureReason: Non-Compliant Accounts: 2
     .EXAMPLE
-        PS> Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -M365DomainForPWPolicyTest "contoso.com" -ELevel "E5" -ProfileLevel "L1"
+        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.
         Output:
@@ -62,7 +66,7 @@
                         user2@domain.com| Global Administrator   | Hybrid       | AAD_PREMIUM, AAD_PREMIUM_P2
         FailureReason: Non-Compliant Accounts: 2
     .EXAMPLE
-        PS> Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -M365DomainForPWPolicyTest "contoso.com" -IncludeIG1
+        PS> Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -DomainName "contoso.com" -IncludeIG1
 
         Performs an audit including all tests where IG1 is true.
         Output:
@@ -78,7 +82,7 @@
                         user2@domain.com| Global Administrator   | Hybrid       | AAD_PREMIUM, AAD_PREMIUM_P2
         FailureReason: Non-Compliant Accounts: 2
     .EXAMPLE
-        PS> Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -M365DomainForPWPolicyTest "contoso.com" -SkipRecommendation '1.1.3', '2.1.1'
+        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.
         Output:
         Status      : Fail
@@ -93,7 +97,7 @@
                         user2@domain.com| Global Administrator   | Hybrid       | AAD_PREMIUM, AAD_PREMIUM_P2
         FailureReason: Non-Compliant Accounts: 2
     .EXAMPLE
-        PS> $auditResults = Invoke-M365SecurityAudit -TenantAdminUrl "https://contoso-admin.sharepoint.com" -M365DomainForPWPolicyTest "contoso.com"
+        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.
@@ -128,32 +132,25 @@ function Invoke-M365SecurityAudit {
         [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 = $false, HelpMessage = "Specify this to test only the default domain for password expiration policy when '1.3.1' is included in the tests to be run. The domain name of your organization, e.g., 'example.com'.")]
+        [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]$M365DomainForPWPolicyTest,
-
+        [string]$DomainName,
         # E-Level with optional ProfileLevel selection
-        [Parameter(Mandatory = $true, ParameterSetName = 'ELevelFilter')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'ELevelFilter', HelpMessage = "Specifies the E-Level (E3 or E5) for the audit.")]
         [ValidateSet('E3', 'E5')]
         [string]$ELevel,
-
-        [Parameter(Mandatory = $true, 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(Mandatory = $true, ParameterSetName = 'IG1Filter')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'IG1Filter', HelpMessage = "Includes tests where IG1 is true.")]
         [switch]$IncludeIG1,
-
-        [Parameter(Mandatory = $true, ParameterSetName = 'IG2Filter')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'IG2Filter', HelpMessage = "Includes tests where IG2 is true.")]
         [switch]$IncludeIG2,
-
-        [Parameter(Mandatory = $true, ParameterSetName = 'IG3Filter')]
+        [Parameter(Mandatory = $true, ParameterSetName = 'IG3Filter', HelpMessage = "Includes tests where IG3 is true.")]
         [switch]$IncludeIG3,
-
         # Inclusion of specific recommendation numbers
-        [Parameter(Mandatory = $true, 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.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', `
@@ -164,9 +161,8 @@ function Invoke-M365SecurityAudit {
                 '8.5.7', '8.6.1'
         )]
         [string[]]$IncludeRecommendation,
-
         # Exclusion of specific recommendation numbers
-        [Parameter(Mandatory = $true, 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.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', `
@@ -177,24 +173,32 @@ 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,
+        [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
     )
-
     Begin {
         if ($script:MaximumFunctionCount -lt 8192) {
             $script:MaximumFunctionCount = 8192
         }
         # Ensure required modules are installed
         $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("Check for required modules: $requiredModulesFormatted", "Check")) {
             Write-Host "Checking for and installing required modules..." -ForegroundColor DarkMagenta
@@ -202,13 +206,11 @@ function Invoke-M365SecurityAudit {
                 Assert-ModuleAvailability -ModuleName $module.ModuleName -RequiredVersion $module.RequiredVersion -SubModules $module.SubModules
             }
         }
-
         # 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
         $params = @{
             TestDefinitions       = $testDefinitions
@@ -237,17 +239,14 @@ function Invoke-M365SecurityAudit {
         # Initialize a collection to hold failed test details
         $script:FailedTests = [System.Collections.ArrayList]::new()
     } # End Begin
-
     Process {
         $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 }
-
         $totalTests = $testFiles.Count
         $currentTestIndex = 0
-
         # Establishing connections if required
         try {
             $actualUniqueConnections = Get-UniqueConnection -Connections $requiredConnections
@@ -260,8 +259,6 @@ function Invoke-M365SecurityAudit {
             Write-Host "Connection execution aborted: $_" -ForegroundColor Red
             break
         }
-
-
         try {
             Write-Host "A total of $($totalTests) tests were selected to run..." -ForegroundColor DarkMagenta
             # Import the test functions
@@ -278,7 +275,6 @@ function Invoke-M365SecurityAudit {
                     $script:FailedTests.Add([PSCustomObject]@{ Test = $_.Name; Error = $_ })
                 }
             }
-
             $currentTestIndex = 0
             # Execute each test function from the prepared list
             foreach ($testFunction in $testFiles) {
@@ -286,7 +282,7 @@ function Invoke-M365SecurityAudit {
                 Write-Progress -Activity "Executing Tests" -Status "Executing $($currentTestIndex) of $($totalTests): $($testFunction.Name)" -PercentComplete (($currentTestIndex / $totalTests) * 100)
                 $functionName = $testFunction.BaseName
                 if ($PSCmdlet.ShouldProcess($functionName, "Execute test")) {
-                    $auditResult = Invoke-TestFunction -FunctionFile $testFunction -DomainName $M365DomainForPWPolicyTest
+                    $auditResult = Invoke-TestFunction -FunctionFile $testFunction -DomainName $DomainName -ApprovedCloudStorageProviders $ApprovedCloudStorageProviders -ApprovedFederatedDomains $ApprovedFederatedDomains
                     # Add the result to the collection
                     [void]$allAuditResults.Add($auditResult)
                 }
@@ -311,7 +307,6 @@ function Invoke-M365SecurityAudit {
             # 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) {
@@ -323,6 +318,3 @@ function Invoke-M365SecurityAudit {
         }
     }
 }
-
-
-

source/en-US/about_M365FoundationsCISReport.help.txt

@@ -1,24 +1,79 @@
-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"
     
-NOTE:
-    Thank you to all those who contributed to this module, by writing code, sharing opinions, and provided feedback.
+    # Example 2: Exporting a security audit table to a CSV file
+    Export-M365SecurityAuditTable -ExportAllTests -AuditResults $auditResults -ExportPath "C:\temp" -ExportOriginalTests
     
-TROUBLESHOOTING NOTE:
-    Look out on the Github repository for issues and new releases.
+    # 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'
+
+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
-    - {{ 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/tests/Test-AdministrativeAccountCompliance.ps1

@@ -1,7 +1,6 @@
 function Test-AdministrativeAccountCompliance {
     [CmdletBinding()]
     param ()
-
     begin {
         # The following conditions are checked:
         # Condition A: The administrative account is cloud-only (not synced).
@@ -11,16 +10,12 @@ function Test-AdministrativeAccountCompliance {
         $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) {
@@ -29,21 +24,16 @@ function Test-AdministrativeAccountCompliance {
                     $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
@@ -57,17 +47,14 @@ function Test-AdministrativeAccountCompliance {
                     }
                 }
             }
-
             # 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 {
@@ -75,7 +62,6 @@ function Test-AdministrativeAccountCompliance {
                 $_.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 {
@@ -88,13 +74,10 @@ function Test-AdministrativeAccountCompliance {
             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
@@ -103,7 +86,6 @@ function Test-AdministrativeAccountCompliance {
                 Details       = $details
                 FailureReason = $failureReason
             }
-
             $auditResult = Initialize-CISAuditResult @params
         }
         catch {
@@ -111,7 +93,6 @@ function Test-AdministrativeAccountCompliance {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Output the result
         return $auditResult

source/tests/Test-AntiPhishingPolicy.ps1

@@ -1,104 +1,227 @@
 function Test-AntiPhishingPolicy {
     [CmdletBinding()]
     [OutputType([CISAuditResult])]
-    param (
-        # Aligned
-        # Parameters can be added if needed
-    )
-
+    param ()
     begin {
-        # Dot source the class script if necessary
-        #. .\source\Classes\CISAuditResult.ps1
-        # Initialization code, if needed
-        #$auditResults = @()
         $recnum = "2.1.7"
-
+        Write-Verbose "Running Test-AntiPhishingPolicy for $recnum..."
+        #. .\source\Classes\CISAuditResult.ps1
         <#
-        Conditions for 2.1.7 (L1) Ensure that an anti-phishing policy has been created
-
+        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: Verify that an anti-phishing policy exists in the Microsoft 365 Security Center.
-          - Condition B: Using PowerShell, ensure the anti-phishing policy is configured with appropriate settings such as enabling impersonation protection and spoof intelligence.
-
+                - 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:
-        - Confirm that the failure conditions in the automated test are consistent with the manual audit results.
+        - Identify any policy misconfigurations or absence of comprehensive coverage.
             - Specific conditions to check:
-          - Condition A: No anti-phishing policy exists in the Microsoft 365 Security Center.
-          - Condition B: Using PowerShell, the anti-phishing policy is not configured with the required settings.
+                - 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 {
-
         try {
-            # Condition A: Ensure that an anti-phishing policy has been created
+            # Step 1: Retrieve all anti-phishing policies
+            #$VerbosePreference = "Continue"
+            Write-Verbose "Retrieving all anti-phishing policies..."
             $antiPhishPolicies = Get-CISExoOutput -Rec $recnum
-
-            # Condition B: Verify the anti-phishing policy settings using PowerShell
-            $validatedPolicies = $antiPhishPolicies | Where-Object {
-                $_.Enabled -eq $true -and
-                $_.PhishThresholdLevel -ge 2 -and
-                $_.EnableMailboxIntelligenceProtection -eq $true -and
-                $_.EnableMailboxIntelligence -eq $true -and
-                $_.EnableSpoofIntelligence -eq $true
+            # 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
                 }
-
-            # Check if there is at least one policy that meets the requirements
-            $nonCompliantItems = $antiPhishPolicies | Where-Object {
-                $_.Enabled -ne $true -or
-                $_.PhishThresholdLevel -lt 2 -or
-                $_.EnableMailboxIntelligenceProtection -ne $true -or
-                $_.EnableMailboxIntelligence -ne $true -or
-                $_.EnableSpoofIntelligence -ne $true
-            }
-            $compliantItems = $validatedPolicies
-            $isCompliant = $compliantItems.Count -gt 0
-
-            # Prepare failure reasons for non-compliant items
-            $nonCompliantNames = $nonCompliantItems | ForEach-Object { $_.Name }
-            $failureReasons = if ($nonCompliantNames.Count -gt 0) {
-                "Reason: Does not meet one or more compliance criteria.`nNon-compliant Policies:`n" + ($nonCompliantNames -join "`n")
+                # 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 {
-                "N/A"
+                        $details += "Is Full Coverage Policy: $($false)`n`n"
                     }
-
-            # Prepare details for non-compliant items
-            $nonCompliantDetails = $nonCompliantItems | ForEach-Object {
-                "Policy: $($_.Name)"
                 }
-            $nonCompliantDetails = $nonCompliantDetails -join "`n"
-
-            # Prepare details based on compliance
-            $details = if ($nonCompliantItems) {
-                "Non-Compliant Items: $($nonCompliantItems.Count)`nDetails:`n$nonCompliantDetails"
+            }
+            # 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 {
-                "Compliant Items: $($compliantItems.Count)"
+                        $details += "Is Full Coverage Policy: $($false)`n`n"
                     }
-
-            # Parameter splat for Initialize-CISAuditResult function
+                }
+            }
+            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        = $nonCompliantItems.Count -eq 0
-                Status        = if ($isCompliant) { "Pass" } else { "Fail" }
-                Details       = $details
-                FailureReason = $failureReasons
+                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." }
             }
-
-            # Create and populate the CISAuditResult object
+            # Initialize the audit result
             $auditResult = Initialize-CISAuditResult @params
         }
         catch {
-            $LastError = $_
-            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+            Write-Error "An error occurred during the test: $_"
+            $auditResult = Get-TestError -LastError $_ -recnum $recnum
         }
     }
-
     end {
-        # Return auditResult
         return $auditResult
     }
 }
+
+

source/tests/Test-AuditDisabledFalse.ps1

@@ -5,11 +5,9 @@ function Test-AuditDisabledFalse {
     param (
         # Parameters can be added if needed
     )
-
     begin {
         # 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:
@@ -25,18 +23,15 @@ function Test-AuditDisabledFalse {
         #   - 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 {
         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
@@ -44,14 +39,12 @@ function Test-AuditDisabledFalse {
             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
@@ -67,7 +60,6 @@ function Test-AuditDisabledFalse {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-AuditLogSearch.ps1

@@ -5,23 +5,20 @@ function Test-AuditLogSearch {
         # Aligned
         # Parameters can be added if needed
     )
-
     begin {
         # 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:
@@ -30,14 +27,10 @@ function Test-AuditLogSearch {
             - Condition C: Audit log search capabilities are non-functional (no search results are displayed for activities within the past 30 days).
         #>
     }
-
     process {
-
         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
@@ -46,7 +39,6 @@ function Test-AuditLogSearch {
             else {
                 "N/A"
             }
-
             $details = if ($auditLogResult) {
                 # Condition A (Pass): Audit log search is enabled in the Microsoft Purview compliance portal
                 "UnifiedAuditLogIngestionEnabled: True"
@@ -54,7 +46,6 @@ function Test-AuditLogSearch {
             else {
                 "UnifiedAuditLogIngestionEnabled: False"
             }
-
             # Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -70,7 +61,6 @@ function Test-AuditLogSearch {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-BlockChannelEmails.ps1

@@ -5,16 +5,14 @@ function Test-BlockChannelEmails {
         # Aligned
         # Parameters can be added here if needed
     )
-
     begin {
         # 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 {
-
         try {
             # 8.1.2 (L1) Ensure users can't send emails to a channel email address
             #
@@ -31,11 +29,9 @@ function Test-BlockChannelEmails {
             #   - 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
@@ -43,14 +39,12 @@ function Test-BlockChannelEmails {
             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
@@ -66,7 +60,6 @@ function Test-BlockChannelEmails {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-BlockMailForwarding.ps1

@@ -4,23 +4,20 @@ function Test-BlockMailForwarding {
     param (
         # Parameters can be added if needed
     )
-
     begin {
         # 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:
@@ -29,26 +26,20 @@ function Test-BlockMailForwarding {
           - Condition C: Unapproved exceptions to the forwarding rules are present.
         #>
     }
-
     process {
         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 ', ')"
@@ -58,7 +49,6 @@ function Test-BlockMailForwarding {
                 }
                 $details += "`n"
             }
-
             if ($nonCompliantSpamPoliciesArray.Count -gt 0) {
                 # Fail Condition B
                 $failureReasons += "Outbound spam policies allowing automatic forwarding found."
@@ -67,7 +57,6 @@ function Test-BlockMailForwarding {
                     "$($_.Name)|$($_.AutoForwardingMode)"
                 }
             }
-
             if ($failureReasons.Count -eq 0) {
                 $failureReasons = "N/A"
                 $details = "Both transport rules and outbound spam policies are configured correctly to block forwarding."
@@ -76,7 +65,6 @@ function Test-BlockMailForwarding {
                 $failureReasons = $failureReasons -join " | "
                 $details = $details -join "`n"
             }
-
             # Populate the audit result
             $params = @{
                 Rec           = $recnum
@@ -92,7 +80,6 @@ function Test-BlockMailForwarding {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-BlockSharedMailboxSignIn.ps1

@@ -8,10 +8,9 @@ function Test-BlockSharedMailboxSignIn {
     begin {
         # 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:
@@ -26,36 +25,59 @@ function Test-BlockSharedMailboxSignIn {
         #   - 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 {
         try {
             # Step: Retrieve shared mailbox details
-            $MBX = Get-CISExoOutput -Rec $recnum
-            $objectids = $MBX.ExternalDirectoryObjectId
+            # $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-CISAadOutput -Rec $recnum
             # Step: Retrieve details of shared mailboxes from Azure AD (Condition B: Pass/Fail)
             $sharedMailboxDetails = $users | Where-Object {$_.objectid -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: $($enabledMailboxes -join ', ')"
+                "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 {
-                "Enabled Mailboxes: $($enabledMailboxes -join ', ')"
+                "AccountEnabled set to True Mailboxes: $($enabledMailboxes -join ', ')"
             }
-
             # Step: Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -71,7 +93,6 @@ function Test-BlockSharedMailboxSignIn {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-CommonAttachmentFilter.ps1

@@ -5,18 +5,15 @@ function Test-CommonAttachmentFilter {
         # Aligned
         # Parameters can be added if needed
     )
-
     begin {
         <#
             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:
@@ -24,22 +21,21 @@ function Test-CommonAttachmentFilter {
                 - 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 {
         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.
@@ -49,14 +45,12 @@ function Test-CommonAttachmentFilter {
             else {
                 "N/A"
             }
-
             $details = if ($result) {
                 "File Filter Enabled: True"
             }
             else {
                 "File Filter Enabled: False"
             }
-
             # Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -72,7 +66,6 @@ function Test-CommonAttachmentFilter {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-CustomerLockbox.ps1

@@ -12,7 +12,7 @@ function Test-CustomerLockbox {
 
         # 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:
@@ -29,12 +29,12 @@ function Test-CustomerLockbox {
         #   - 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 {
         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."
@@ -42,7 +42,6 @@ function Test-CustomerLockbox {
             else {
                 "N/A"
             }
-
             # Step: Prepare details for the audit result (Condition A, B, & C: Pass/Fail)
             $details = if ($customerLockboxEnabled) {
                 "Customer Lockbox Enabled: True"
@@ -50,7 +49,6 @@ function Test-CustomerLockbox {
             else {
                 "Customer Lockbox Enabled: False"
             }
-
             # Step: Create and populate the CISAuditResult object
             $params = @{
                 Rec            = $recnum
@@ -66,7 +64,6 @@ function Test-CustomerLockbox {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-DialInBypassLobby.ps1

@@ -5,16 +5,14 @@ function Test-DialInBypassLobby {
         # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
         # 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 {
-
         try {
             # 8.5.4 (L1) Ensure users dialing in can't bypass the lobby
             #
@@ -31,11 +29,15 @@ function Test-DialInBypassLobby {
             #   - 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"
@@ -43,14 +45,12 @@ function Test-DialInBypassLobby {
             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
@@ -66,7 +66,6 @@ function Test-DialInBypassLobby {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-EnableDKIM.ps1

@@ -4,24 +4,21 @@ function Test-EnableDKIM {
     param (
         # Aligned
         # Parameters can be added if needed
+        [string]$DomainName
     )
-
     begin {
         # 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:
@@ -29,17 +26,21 @@ function Test-EnableDKIM {
           - Condition B: Using the Exchange Online PowerShell Module, the `CnameConfiguration.Enabled` property for one or more domains is set to `False`.
         #>
     }
-
     process {
-
         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
@@ -47,14 +48,18 @@ function Test-EnableDKIM {
             else {
                 "N/A"
             }
-
+            $basedetails = "All domains have DKIM enabled"
             $details = if ($dkimResult) {
-                "All domains have DKIM enabled"  # Condition A pass
+                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
@@ -70,7 +75,6 @@ function Test-EnableDKIM {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-ExternalNoControl.ps1

@@ -5,17 +5,14 @@ function Test-ExternalNoControl {
         # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
         # 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 {
-
         try {
             # 8.5.7 (L1) Ensure external participants can't give or request control
             #
@@ -32,12 +29,16 @@ function Test-ExternalNoControl {
             #   - 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"
@@ -45,14 +46,12 @@ function Test-ExternalNoControl {
             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
@@ -68,7 +67,6 @@ function Test-ExternalNoControl {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-ExternalSharingCalendars.ps1

@@ -5,14 +5,12 @@ function Test-ExternalSharingCalendars {
         # Aligned
         # Parameters can be added if needed
     )
-
     begin {
         # Dot source the class script if necessary
         #. .\source\Classes\CISAuditResult.ps1
-
         # Initialization code, if needed
         $recnum = "1.3.3"
-
+        Write-Verbose "Running Test-ExternalSharingCalendars for $recnum..."
         # Conditions for 1.3.3 (L2) Ensure 'External sharing' of calendars is not available (Automated)
         #
         # Validate test for a pass:
@@ -27,12 +25,19 @@ function Test-ExternalSharingCalendars {
         #   - 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 {
         try {
             # 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-CISExoOutput -Rec $recnum
-
             # Step (Condition A & B: Pass/Fail): Check if calendar sharing is disabled in all applicable policies
             $isExternalSharingDisabled = $true
             $sharingPolicyDetails = @()
@@ -42,23 +47,43 @@ function Test-ExternalSharingCalendars {
                     $sharingPolicyDetails += "$($policy.Name): Enabled"
                 }
             }
-
-            # Step: Prepare failure reasons and details based on compliance (Condition A & B: Fail)
+            # Retrieve calendars with publishing enabled (from 1.3.3b)
+            # $calendarDetails Mock Object
+            <#
+                $calendarDetails = @(
+                    [PSCustomObject]@{
+                        Calendar = "SMBuser1@domain.com"
+                        URL = "https://example.com/calendar/smbuser1"
+                    },
+                    [PSCustomObject]@{
+                        Calendar = "SMBuser2@domain.com"
+                        URL = "https://example.com/calendar/smbuser2"
+                    },
+                    [PSCustomObject]@{
+                        Calendar = "SMBuser4@domain.com"
+                        URL = "https://example.com/calendar/smbuser3"
+                    }
+                )
+            #>
+            $calendarDetails = Get-CISExoOutput -Rec "$("$recnum" + "b")"
+            # Build the failure reason string
             $failureReasons = if (-not $isExternalSharingDisabled) {
-                "Calendar sharing with external users is enabled in one or more policies."
+                $baseMessage = "Calendar sharing with external users is enabled in one or more policies."
+                if ($calendarDetails.Count -gt 0) {
+                    $baseMessage += "`nPrior to remediating, check the following mailboxes that have calendar publishing enabled: `n$($calendarDetails -join '`n')"
+                }
+                $baseMessage
             }
             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 ', ')"
+                "Enabled Sharing Policies:`n$($sharingPolicyDetails -join ', ')"
             }
-
             # Step: Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -74,7 +99,6 @@ function Test-ExternalSharingCalendars {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-GlobalAdminsCount.ps1

@@ -4,7 +4,6 @@ function Test-GlobalAdminsCount {
     param (
         # Define your parameters here if needed
     )
-
     begin {
                 # Dot source the class script if necessary
         #. .\source\Classes\CISAuditResult.ps1
@@ -23,23 +22,19 @@ function Test-GlobalAdminsCount {
         #   - 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 {
         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"
@@ -50,10 +45,8 @@ function Test-GlobalAdminsCount {
             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
@@ -69,7 +62,6 @@ function Test-GlobalAdminsCount {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-IdentifyExternalEmail.ps1

@@ -9,10 +9,9 @@ function Test-IdentifyExternalEmail {
     begin {
         # 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:
@@ -29,16 +28,12 @@ function Test-IdentifyExternalEmail {
         #   - Condition B: The BypassAllowList contains unauthorized email addresses.
         #   - Condition C: External sender tag does not appear in email messages received from external sources.
     }
-
     process {
-
         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.
@@ -47,10 +42,8 @@ function Test-IdentifyExternalEmail {
             else {
                 "N/A"
             }
-
             # Details for external tagging configuration
             $details = "Enabled: $($externalTaggingEnabled); AllowList: $($externalInOutlook.AllowList)"
-
             # Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -66,7 +59,6 @@ function Test-IdentifyExternalEmail {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-MailTipsEnabled.ps1

@@ -5,15 +5,12 @@ function Test-MailTipsEnabled {
         # Aligned
         # Parameters can be added if needed
     )
-
     begin {
         # Dot source the class script if necessary
         #. .\source\Classes\CISAuditResult.ps1
         # Initialization code, if needed
-
-        $auditResult = [CISAuditResult]::new()
         $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:
@@ -32,18 +29,14 @@ function Test-MailTipsEnabled {
         #   - Condition C: MailTipsGroupMetricsEnabled is not set to True.
         #   - Condition D: MailTipsLargeAudienceThreshold is not set to an acceptable value (default is 25).
     }
-
     process {
         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."
@@ -51,14 +44,12 @@ function Test-MailTipsEnabled {
             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
@@ -74,7 +65,6 @@ function Test-MailTipsEnabled {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-MailboxAuditingE3.ps1

@@ -4,11 +4,9 @@ function Test-MailboxAuditingE3 {
     param (
         # Parameters can be added if needed
     )
-
     begin {
         <#
         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:
@@ -16,7 +14,6 @@ function Test-MailboxAuditingE3 {
           - 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:
@@ -25,24 +22,19 @@ function Test-MailboxAuditingE3 {
           - 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
-
-
         $actionDictionaries = Get-Action -Dictionaries
         # E3 specific actions
         $AdminActions = $actionDictionaries.AdminActions.Keys | Where-Object { $_ -notin @("MailItemsAccessed", "Send") }
         $DelegateActions = $actionDictionaries.DelegateActions.Keys | Where-Object { $_ -notin @("MailItemsAccessed") }
         $OwnerActions = $actionDictionaries.OwnerActions.Keys | Where-Object { $_ -notin @("MailItemsAccessed", "Send") }
-
         $allFailures = @()
         $recnum = "6.1.2"
+        Write-Verbose "Running Test-MailboxAuditingE3 for $recnum..."
         $allUsers = Get-CISMgOutput -Rec $recnum
         $processedUsers = @{}  # Dictionary to track processed users
-
     }
-
     process {
         if ($null -ne $allUsers) {
             $mailboxes = Get-CISExoOutput -Rec $recnum
@@ -52,14 +44,11 @@ function Test-MailboxAuditingE3 {
                         Write-Verbose "Skipping already processed user: $($user.UserPrincipalName)"
                         continue
                     }
-
                     $userUPN = $user.UserPrincipalName
                     $mailbox = $mailboxes | Where-Object { $_.UserPrincipalName -eq $user.UserPrincipalName }
-
                     $missingAdminActions = @()
                     $missingDelegateActions = @()
                     $missingOwnerActions = @()
-
                     if ($mailbox.AuditEnabled) {
                         foreach ($action in $AdminActions) {
                             if ($mailbox.AuditAdmin -notcontains $action) {
@@ -76,7 +65,6 @@ function Test-MailboxAuditingE3 {
                                 $missingOwnerActions += (Get-Action -Actions $action -ActionType "Owner")
                             }
                         }
-
                         if ($missingAdminActions.Count -gt 0 -or $missingDelegateActions.Count -gt 0 -or $missingOwnerActions.Count -gt 0) {
                             $allFailures += "$userUPN|True|$($missingAdminActions -join ',')|$($missingDelegateActions -join ',')|$($missingOwnerActions -join ',')"
                         }
@@ -84,11 +72,9 @@ function Test-MailboxAuditingE3 {
                     else {
                         $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"
@@ -102,7 +88,6 @@ function Test-MailboxAuditingE3 {
                 else {
                     "UserPrincipalName|AuditEnabled|AdminActionsMissing|DelegateActionsMissing|OwnerActionsMissing`n" + ($allFailures -join "`n")
                 }
-
                 # Populate the audit result
                 $params = @{
                     Rec           = $recnum
@@ -115,13 +100,10 @@ function Test-MailboxAuditingE3 {
             }
             catch {
                 Write-Error "An error occurred during the test: $_"
-
                 # 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
             }
@@ -137,15 +119,12 @@ function Test-MailboxAuditingE3 {
             $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
     }
 }

source/tests/Test-MailboxAuditingE5.ps1

@@ -4,11 +4,9 @@ function Test-MailboxAuditingE5 {
     param (
         # Parameters can be added if needed
     )
-
     begin {
         # 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:
@@ -26,18 +24,16 @@ function Test-MailboxAuditingE5 {
         #   - 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.
-
         $actionDictionaries = Get-Action -Dictionaries
         $AdminActions = $actionDictionaries.AdminActions.Keys
         $DelegateActions = $actionDictionaries.DelegateActions.Keys
         $OwnerActions = $actionDictionaries.OwnerActions.Keys
-
         $allFailures = @()
         $processedUsers = @{}
         $recnum = "6.1.3"
+        Write-Verbose "Running Test-MailboxAuditingE5 for $recnum..."
         $allUsers = Get-CISMgOutput -Rec $recnum
     }
-
     process {
         if ($null -ne $allUsers) {
             $mailboxes = Get-CISExoOutput -Rec $recnum
@@ -47,14 +43,11 @@ function Test-MailboxAuditingE5 {
                         Write-Verbose "Skipping already processed user: $($user.UserPrincipalName)"
                         continue
                     }
-
                     $mailbox = $mailboxes | Where-Object { $_.UserPrincipalName -eq $user.UserPrincipalName }
                     $userUPN = $user.UserPrincipalName
-
                     $missingAdminActions = @()
                     $missingDelegateActions = @()
                     $missingOwnerActions = @()
-
                     if ($mailbox.AuditEnabled) {
                         # Validate Admin actions
                         foreach ($action in $AdminActions) {
@@ -74,7 +67,6 @@ function Test-MailboxAuditingE5 {
                                 $missingOwnerActions += (Get-Action -Actions $action -ActionType "Owner") # 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 ',')"
                         }
@@ -82,11 +74,9 @@ function Test-MailboxAuditingE5 {
                     else {
                         $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"
@@ -113,13 +103,10 @@ function Test-MailboxAuditingE5 {
             }
             catch {
                 Write-Error "An error occurred during the test: $_"
-
                 # 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
             }
@@ -135,15 +122,12 @@ function Test-MailboxAuditingE5 {
             $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
     }
 }

source/tests/Test-ManagedApprovedPublicGroups.ps1

@@ -4,14 +4,12 @@ function Test-ManagedApprovedPublicGroups {
     param (
         # Parameters can be added if needed
     )
-
     begin {
         # 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:
@@ -26,12 +24,10 @@ function Test-ManagedApprovedPublicGroups {
         #   - 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 {
         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."
@@ -39,7 +35,6 @@ function Test-ManagedApprovedPublicGroups {
             else {
                 "N/A"
             }
-
             # Step: Prepare details for the audit result
             $details = if ($null -eq $allGroups -or $allGroups.Count -eq 0) {
                 "No public groups found."
@@ -48,7 +43,6 @@ function Test-ManagedApprovedPublicGroups {
                 $groupDetails = $allGroups | ForEach-Object { $_.DisplayName + " (" + $_.Visibility + ")" }
                 "Public groups found: $($groupDetails -join ', ')"
             }
-
             # Step: Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -64,7 +58,6 @@ function Test-ManagedApprovedPublicGroups {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-MeetingChatNoAnonymous.ps1

@@ -5,14 +5,13 @@ function Test-MeetingChatNoAnonymous {
         # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
         # 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 {
         try {
             # 8.5.5 (L2) Ensure meeting chat does not allow anonymous users
@@ -30,22 +29,24 @@ function Test-MeetingChatNoAnonymous {
             #   - 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"
+                "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
@@ -61,7 +62,6 @@ function Test-MeetingChatNoAnonymous {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-ModernAuthExchangeOnline.ps1

@@ -5,11 +5,9 @@ function Test-ModernAuthExchangeOnline {
         # Aligned
         # Define your parameters here
     )
-
     begin {
         # 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:
@@ -25,17 +23,14 @@ function Test-ModernAuthExchangeOnline {
         #   - 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 {
             # 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-CISExoOutput -Rec $recnum
-
             # Prepare failure reasons and details based on compliance
             $failureReasons = if (-not $orgConfig.OAuth2ClientProfileEnabled) {
                 "Modern authentication is disabled"
@@ -43,10 +38,8 @@ function Test-ModernAuthExchangeOnline {
             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
@@ -56,15 +49,12 @@ function Test-ModernAuthExchangeOnline {
                 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-NoAnonymousMeetingJoin.ps1

@@ -5,14 +5,13 @@ function Test-NoAnonymousMeetingJoin {
         # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
         # 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 {
         try {
             # 8.5.1 (L2) Ensure anonymous users can't join a meeting
@@ -30,22 +29,23 @@ function Test-NoAnonymousMeetingJoin {
             #   - 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"
+                "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
@@ -61,7 +61,6 @@ function Test-NoAnonymousMeetingJoin {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-NoAnonymousMeetingStart.ps1

@@ -5,14 +5,13 @@ function Test-NoAnonymousMeetingStart {
         # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
         # 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 {
         try {
             # 8.5.2 (L1) Ensure anonymous users and dial-in callers can't start a meeting
@@ -30,13 +29,10 @@ function Test-NoAnonymousMeetingStart {
             #   - 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"
@@ -44,9 +40,7 @@ function Test-NoAnonymousMeetingStart {
             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
@@ -62,7 +56,6 @@ function Test-NoAnonymousMeetingStart {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-NoWhitelistDomains.ps1

@@ -5,24 +5,20 @@ function Test-NoWhitelistDomains {
         # Aligned
         # Define your parameters here
     )
-
     begin {
         # 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:
@@ -31,11 +27,9 @@ function Test-NoWhitelistDomains {
           - Condition C: Manual review in Exchange Online admin center shows whitelisted domains in transport rules.
         #>
     }
-
     process {
         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
@@ -47,7 +41,6 @@ function Test-NoWhitelistDomains {
             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 ', ') }
@@ -56,7 +49,6 @@ function Test-NoWhitelistDomains {
             else {
                 "No transport rules whitelisting specific domains found."
             }
-
             # Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -72,7 +64,6 @@ function Test-NoWhitelistDomains {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return auditResult
         return $auditResult

source/tests/Test-NotifyMalwareInternal.ps1

@@ -5,7 +5,6 @@ function Test-NotifyMalwareInternal {
         # Aligned
         # Parameters can be added if needed
     )
-
     begin {
         <#
         # Conditions for 2.1.3 (L1) Ensure notifications for internal users sending malware is Enabled
@@ -22,20 +21,33 @@ function Test-NotifyMalwareInternal {
         #   - 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 {
         try {
             # 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-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) {
@@ -43,10 +55,8 @@ function Test-NotifyMalwareInternal {
                     $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"
@@ -55,14 +65,12 @@ function Test-NotifyMalwareInternal {
                 # 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 ', ')"
+                "Misconfigured Policies: $($policiesToReport -join '`n')"
             }
-
             # Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -78,7 +86,6 @@ function Test-NotifyMalwareInternal {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-OrgOnlyBypassLobby.ps1

@@ -5,14 +5,13 @@ function Test-OrgOnlyBypassLobby {
         # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
         # 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 {
         try {
             # 8.5.3 (L1) Ensure only people in my org can bypass the lobby
@@ -30,31 +29,24 @@ function Test-OrgOnlyBypassLobby {
             #   - 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 A: The `AutoAdmittedUsers` setting in the Teams meeting policy is not set to `EveryoneInCompanyExcludingGuests`.
-                "External participants can bypass the lobby"
-            }
-            else {
+                # 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"
             }
-            else {
-                # 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)"
-            }
-
             # Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -70,7 +62,6 @@ function Test-OrgOnlyBypassLobby {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-OrganizersPresent.ps1

@@ -5,14 +5,13 @@ function Test-OrganizersPresent {
         # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
         # 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 {
         try {
             # 8.5.6 (L2) Ensure only organizers and co-organizers can present
@@ -30,26 +29,28 @@ function Test-OrganizersPresent {
             #   - 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"
+                "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
@@ -65,7 +66,6 @@ function Test-OrganizersPresent {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-PasswordHashSync.ps1

@@ -5,7 +5,6 @@ function Test-PasswordHashSync {
         # Aligned
         # Parameters can be added if needed
     )
-
     begin {
         # Conditions for 5.1.8.1 (L1) Ensure password hash sync is enabled for hybrid deployments
         #
@@ -22,21 +21,18 @@ function Test-PasswordHashSync {
         #   - 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 {
         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"
@@ -44,9 +40,7 @@ function Test-PasswordHashSync {
             else {
                 "N/A"
             }
-
             $details = "OnPremisesSyncEnabled: $($passwordHashSync)"
-
             # Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -62,7 +56,6 @@ function Test-PasswordHashSync {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-ReportSecurityInTeams.ps1

@@ -5,47 +5,91 @@ function Test-ReportSecurityInTeams {
         # Aligned
         # Parameters can be defined here if needed
     )
-
     begin {
         # Dot source the class script if necessary
         #. .\source\Classes\CISAuditResult.ps1
-
         # Initialization code, if needed
         $recnum = "8.6.1"
+        Write-Verbose "Running Test-ReportSecurityInTeams for $recnum..."
     }
-
     process {
         try {
             # 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-CISMSTeamsOutput -Rec $recnum
             # 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-CISExoOutput -Rec $recnum
             # Check if all the required settings are enabled
             $securityReportEnabled = $CsTeamsMessagingPolicy.AllowSecurityEndUserReporting -and
             $ReportSubmissionPolicy.ReportJunkToCustomizedAddress -and
             $ReportSubmissionPolicy.ReportNotJunkToCustomizedAddress -and
             $ReportSubmissionPolicy.ReportPhishToCustomizedAddress -and
-            $ReportSubmissionPolicy.ReportChatMessageToCustomizedAddressEnabled
+            $null -ne $ReportSubmissionPolicy.ReportJunkAddresses -and
+            $null -ne $ReportSubmissionPolicy.ReportNotJunkAddresses -and
+            $null -ne $ReportSubmissionPolicy.ReportPhishAddresses -and
+            $ReportSubmissionPolicy.ReportChatMessageToCustomizedAddressEnabled -and
+            -not $ReportSubmissionPolicy.ReportChatMessageEnabled
+            $detailsString = @"
+The following settings are required for users to report security concerns in Teams:
 
+MS Teams:
+AllowSecurityEndUserReporting: True
+
+EXO:
+ReportJunkToCustomizedAddress: True
+ReportNotJunkToCustomizedAddress: True
+ReportPhishToCustomizedAddress: True
+ReportJunkAddresses: <security@contoso.com>
+ReportNotJunkAddresses: <security@contoso.com>
+ReportPhishAddresses: <security@contoso.com>
+ReportChatMessageEnabled: False
+ReportChatMessageToCustomizedAddressEnabled: True
+"@
+            $faildetailstring = "Users cannot report security concerns in Teams due to one or more  of the found incorrect settings:`n`n" +
+            "MSTeams: `nAllowSecurityEndUserReporting: $($CsTeamsMessagingPolicy.AllowSecurityEndUserReporting); `n`n" +
+            "EXO: `nReportJunkToCustomizedAddress: $($ReportSubmissionPolicy.ReportJunkToCustomizedAddress); `n" +
+            "ReportNotJunkToCustomizedAddress: $($ReportSubmissionPolicy.ReportNotJunkToCustomizedAddress); `n" +
+            "ReportPhishToCustomizedAddress: $($ReportSubmissionPolicy.ReportPhishToCustomizedAddress); `n" +
+            "ReportJunkAddresses: $($ReportSubmissionPolicy.ReportJunkAddresses -join ', '); `n" +
+            "ReportNotJunkAddresses: $($ReportSubmissionPolicy.ReportNotJunkAddresses -join ', '); `n" +
+            "ReportPhishAddresses: $($ReportSubmissionPolicy.ReportPhishAddresses -join ', '); `n" +
+            "ReportChatMessageEnabled: $($ReportSubmissionPolicy.ReportChatMessageEnabled); `n" +
+            "ReportChatMessageToCustomizedAddressEnabled: $($ReportSubmissionPolicy.ReportChatMessageToCustomizedAddressEnabled); "
             # Prepare failure reasons and details based on compliance
             $failureReasons = if (-not $securityReportEnabled) {
-                "Users cannot report security concerns in Teams due to one or more incorrect settings"
+                $detailsString
             }
             else {
                 "N/A"
             }
-
-            $details = "AllowSecurityEndUserReporting: $($CsTeamsMessagingPolicy.AllowSecurityEndUserReporting); " +
-            "ReportJunkToCustomizedAddress: $($ReportSubmissionPolicy.ReportJunkToCustomizedAddress); " +
-            "ReportNotJunkToCustomizedAddress: $($ReportSubmissionPolicy.ReportNotJunkToCustomizedAddress); " +
-            "ReportPhishToCustomizedAddress: $($ReportSubmissionPolicy.ReportPhishToCustomizedAddress); " +
-            "ReportChatMessageToCustomizedAddressEnabled: $($ReportSubmissionPolicy.ReportChatMessageToCustomizedAddressEnabled)"
-
+            $details = if ($securityReportEnabled) {
+                "Users can report security concerns in Teams."
+            }
+            else {
+                $faildetailstring
+            }
             # Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -61,7 +105,6 @@ function Test-ReportSecurityInTeams {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-RestrictOutlookAddins.ps1

@@ -5,16 +5,14 @@ function Test-RestrictOutlookAddins {
         # Aligned
         # Parameters could include credentials or other necessary data
     )
-
     begin {
         # Dot source the class script if necessary
         #. .\source\Classes\CISAuditResult.ps1
-
         # Initialization code
         $defaultPolicyFailureDetails = @()
         $relevantRoles = @('My Custom Apps', 'My Marketplace Apps', 'My ReadWriteMailbox Apps')
         $recnum = "6.3.1"
-
+        Write-Verbose "Running Test-RestrictOutlookAddins for $recnum..."
         # Conditions for 6.3.1 (L2) Ensure users installing Outlook add-ins is not allowed
         #
         # Validate test for a pass:
@@ -29,21 +27,17 @@ function Test-RestrictOutlookAddins {
         #   - Condition A: One or more of the roles MyCustomApps, MyMarketplaceApps, and MyReadWriteMailboxApps are checked under Other roles.
         #   - Condition B: Using PowerShell, verify that MyCustomApps, MyMarketplaceApps, and MyReadWriteMailboxApps are assigned to users.
     }
-
     process {
         try {
             # 6.3.1 (L2) Ensure users installing Outlook add-ins is not allowed
-
             # Check all mailboxes for custom policies with unallowed add-ins
             # Check Default Role Assignment Policy
             $customPolicyFailures, $defaultPolicy = Get-CISExoOutput -Rec $recnum
             $defaultPolicyRoles = $defaultPolicy.AssignedRoles | Where-Object { $_ -in $relevantRoles }
-
             # Condition A: Verify that the roles MyCustomApps, MyMarketplaceApps, and MyReadWriteMailboxApps are unchecked under Other roles.
             if ($defaultPolicyRoles) {
                 $defaultPolicyFailureDetails = $defaultPolicyRoles
             }
-
             # Prepare result details string
             $detailsString = ""
             if ($customPolicyFailures) {
@@ -53,7 +47,6 @@ function Test-RestrictOutlookAddins {
             else {
                 $detailsString += "Custom Policy Failures: None | "
             }
-
             $detailsString += "Default Role Assignment Policy: "
             if ($defaultPolicyFailureDetails) {
                 $detailsString += ($defaultPolicyFailureDetails -join ', ')
@@ -61,10 +54,8 @@ function Test-RestrictOutlookAddins {
             else {
                 $detailsString += "Compliant"
             }
-
             # Determine result based on findings
             $isCompliant = -not ($customPolicyFailures -or $defaultPolicyFailureDetails)
-
             # Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -80,7 +71,6 @@ function Test-RestrictOutlookAddins {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-RestrictStorageProvidersOutlook.ps1

@@ -5,7 +5,6 @@ function Test-RestrictStorageProvidersOutlook {
         # Aligned
         # Parameters can be added here if needed
     )
-
     begin {
         <#
         # 6.5.3 (L2) Ensure additional storage providers are restricted in Outlook on the web
@@ -22,25 +21,21 @@ function Test-RestrictStorageProvidersOutlook {
         #   - Condition A: Using PowerShell, verify that `AdditionalStorageProvidersAvailable` is not set to `False` in the OwaMailboxPolicy.
         #   - Condition B: Ensure that the command `Get-OwaMailboxPolicy | Format-Table Name, AdditionalStorageProvidersAvailable` does not return `False`.
         #>
-
         # Dot source the class script if necessary
         #. .\source\Classes\CISAuditResult.ps1
         # Initialization code, if needed
         $recnum = "6.5.3"
+        Write-Verbose "Running Test-RestrictStorageProvidersOutlook for $recnum..."
     }
-
     process {
         try {
             # 6.5.3 (L2) Ensure additional storage providers are restricted in Outlook on the web
-
             # Retrieve all OwaMailbox policies
             $owaPolicies = Get-CISExoOutput -Rec $recnum
             # Condition A: Check if AdditionalStorageProvidersAvailable is set to False
             $nonCompliantPolicies = $owaPolicies | Where-Object { $_.AdditionalStorageProvidersAvailable }
-
             # Determine compliance
             $allPoliciesRestricted = $nonCompliantPolicies.Count -eq 0
-
             # Prepare failure reasons and details based on compliance
             $failureReasons = if ($allPoliciesRestricted) {
                 "N/A"
@@ -48,14 +43,12 @@ function Test-RestrictStorageProvidersOutlook {
             else {
                 "One or more OwaMailbox policies allow AdditionalStorageProvidersAvailable."
             }
-
             $details = if ($allPoliciesRestricted) {
                 "All OwaMailbox policies restrict AdditionalStorageProvidersAvailable"
             }
             else {
                 "Non-compliant OwaMailbox policies: $($nonCompliantPolicies.Name -join ', ')"
             }
-
             # Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -71,7 +64,6 @@ function Test-RestrictStorageProvidersOutlook {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-RestrictTenantCreation.ps1

@@ -5,23 +5,19 @@ function Test-RestrictTenantCreation {
         # Aligned
         # Parameters can be added if needed
     )
-
     begin {
         # Dot source the class script if necessary
         #. .\source\Classes\CISAuditResult.ps1
-
         # Initialization code, if needed
         $recnum = "5.1.2.3"
-
+        Write-Verbose "Starting Test-RestrictTenantCreation with Rec: $recnum"
         <#
         Conditions for 5.1.2.3 (L1) Ensure 'Restrict non-admin users from creating tenants' is set to 'Yes'
-
         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: Restrict non-admin users from creating tenants is set to 'Yes' in the Azure AD and Entra administration portal.
           - Condition B: Using PowerShell, the setting for restricting non-admin users from creating tenants is set to 'Yes'.
-
         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:
@@ -29,15 +25,12 @@ function Test-RestrictTenantCreation {
           - Condition B: Using PowerShell, the setting for restricting non-admin users from creating tenants is not set to 'Yes'.
         #>
     }
-
     process {
         try {
             # 5.1.2.3 (L1) Ensure 'Restrict non-admin users from creating tenants' is set to 'Yes'
-
             # Retrieve the tenant creation policy
             $tenantCreationPolicy = Get-CISMgOutput -Rec $recnum
             $tenantCreationResult = -not $tenantCreationPolicy.AllowedToCreateTenants
-
             # Prepare failure reasons and details based on compliance
             $failureReasons = if ($tenantCreationResult) {
                 "N/A"
@@ -45,9 +38,7 @@ function Test-RestrictTenantCreation {
             else {
                 "Non-admin users can create tenants"
             }
-
             $details = "AllowedToCreateTenants: $($tenantCreationPolicy.AllowedToCreateTenants)"
-
             # Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
@@ -63,7 +54,6 @@ function Test-RestrictTenantCreation {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-SafeAttachmentsPolicy.ps1

@@ -2,76 +2,68 @@ function Test-SafeAttachmentsPolicy {
     [CmdletBinding()]
     [OutputType([CISAuditResult])]
     param ()
-
     begin {
         $recnum = "2.1.4"
-
+        Write-Verbose "Running Test-SafeAttachmentsPolicy for $recnum..."
         <#
-        Conditions for 2.1.4 (L2) Ensure Safe Attachments policy is enabled
-
+            Conditions for 2.1.4 (L2) Ensure Safe Attachments policy 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 Safe Attachments policy is enabled in the Microsoft 365 Defender portal.
-          - Condition B: The policy covers all recipients within the organization.
-          - Condition C: The policy action is set to "Dynamic Delivery" or "Quarantine".
-          - Condition D: The policy is not disabled.
-
+                - Ensure the highest priority Safe Attachments policy is enabled.
+                - Check if the policy's action is set to 'Block'.
+                - Confirm the QuarantineTag is set to 'AdminOnlyAccessPolicy'.
+                - Verify that the Redirect 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 Safe Attachments policy is not enabled in the Microsoft 365 Defender portal.
-          - Condition B: The policy does not cover all recipients within the organization.
-          - Condition C: The policy action is not set to "Dynamic Delivery" or "Quarantine".
-          - Condition D: The policy is disabled.
+                - If the highest priority Safe Attachments policy's action is not set to 'Block'.
+                - If the QuarantineTag is not set to 'AdminOnlyAccessPolicy'.
+                - If the Redirect setting is enabled.
+                - If no enabled Safe Attachments policies are found.
         #>
     }
-
     process {
+        # 2.1.4 (L2) Ensure Safe Attachments policy is enabled
+        # $safeAttachmentPolicies Mock Object
+        <#
+            $safeAttachmentPolicies = @(
+                [PSCustomObject]@{
+                    Policy        = "Strict Preset Security Policy"
+                    Action        = "Block"
+                    QuarantineTag = "AdminOnlyAccessPolicy"
+                    Redirect      = $false
+                    Enabled       = $true
+                }
+            )
+        #>
         $safeAttachmentPolicies = Get-CISExoOutput -Rec $recnum
         if ($safeAttachmentPolicies -ne 1) {
             try {
-                # Check if any Safe Attachments policy is enabled (Condition A)
-                $result = $null -ne $safeAttachmentPolicies -and $safeAttachmentPolicies.Count -gt 0
-
+                $highestPriorityPolicy = $safeAttachmentPolicies | Select-Object -First 1
                 # Initialize details and failure reasons
                 $details = @()
                 $failureReasons = @()
-
-                foreach ($policy in $safeAttachmentPolicies) {
-                    # Initialize policy detail and failed status
-                    $failed = $false
-
-                    # Check if the policy action is set to "Dynamic Delivery" or "Quarantine" (Condition C)
-                    if ($policy.Action -notin @("DynamicDelivery", "Quarantine")) {
-                        $failureReasons += "Policy '$($policy.Name)' action is not set to 'Dynamic Delivery' or 'Quarantine'."
-                        $failed = $true
+                # Check policy specifics as per CIS benchmark requirements
+                if ($highestPriorityPolicy.Action -ne 'Block') {
+                    $failureReasons += "Policy action is not set to 'Block'."
                 }
-
-                    # Check if the policy is not disabled (Condition D)
-                    if (-not $policy.Enable) {
-                        $failureReasons += "Policy '$($policy.Name)' is disabled."
-                        $failed = $true
+                if ($highestPriorityPolicy.QuarantineTag -ne 'AdminOnlyAccessPolicy') {
+                    $failureReasons += "Quarantine policy is not set to 'AdminOnlyAccessPolicy'."
                 }
-
-                    # Add policy details to the details array
-                    $details += [PSCustomObject]@{
-                        Policy  = $policy.Name
-                        Enabled = $policy.Enable
-                        Action  = $policy.Action
-                        Failed  = $failed
+                if ($highestPriorityPolicy.Redirect -ne $false) {
+                    $failureReasons += "Redirect is not disabled."
                 }
-                }
-
                 # The result is a pass if there are no failure reasons
                 $result = $failureReasons.Count -eq 0
-
+                $details = [PSCustomObject]@{
+                    Policy        = $highestPriorityPolicy.Identity
+                    Action        = $highestPriorityPolicy.Action
+                    QuarantineTag = $highestPriorityPolicy.QuarantineTag
+                    Redirect      = $highestPriorityPolicy.Redirect
+                    Enabled       = $highestPriorityPolicy.Enable
+                }
                 # Format details for output manually
-                $detailsString = "Policy|Enabled|Action|Failed`n" + ($details |
-                    ForEach-Object {"$($_.Policy)|$($_.Enabled)|$($_.Action)|$($_.Failed)`n"}
+                $detailsString = "Policy|Action|QuarantineTag|Redirect|Enabled`n" + ($details |
+                    ForEach-Object { "$($_.Policy)|$($_.Action)|$($_.QuarantineTag)|$($_.Redirect)|$($_.Enabled)`n" }
                 )
-                $failureReasonsString = ($failureReasons | ForEach-Object { $_ }) -join ' '
-
+                $failureReasonsString = ($failureReasons -join "`n")
                 # Create and populate the CISAuditResult object
                 $params = @{
                     Rec           = $recnum
@@ -84,13 +76,10 @@ function Test-SafeAttachmentsPolicy {
             }
             catch {
                 Write-Error "An error occurred during the test: $_"
-
                 # 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
             }
@@ -106,7 +95,6 @@ function Test-SafeAttachmentsPolicy {
             $auditResult = Initialize-CISAuditResult @params
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-SafeAttachmentsTeams.ps1

@@ -5,11 +5,9 @@ function Test-SafeAttachmentsTeams {
         # Aligned
         # Parameters can be added if needed
     )
-
     begin {
         # Dot source the class script if necessary
         #. .\source\Classes\CISAuditResult.ps1
-
         # Conditions for 2.1.5 (L2) Ensure Safe Attachments for SharePoint, OneDrive, and Microsoft Teams is Enabled
         #
         # Validate test for a pass:
@@ -25,35 +23,60 @@ function Test-SafeAttachmentsTeams {
         #   - Condition A: Safe Attachments for SharePoint is not enabled.
         #   - Condition B: Safe Attachments for OneDrive is not enabled.
         #   - Condition C: Safe Attachments for Microsoft Teams is not enabled.
-
         # Initialization code, if needed
         $recnum = "2.1.5"
+        Write-Verbose "Running Test-SafeAttachmentsTeams for $recnum..."
     }
-
     process {
+        # $atpPolicyResult Mock Object
+        <#
+            $atpPolicyResult = @(
+                [PSCustomObject]@{
+                    Name                   = "Default"
+                    EnableATPForSPOTeamsODB = $true
+                    EnableSafeDocs         = $true
+                    AllowSafeDocsOpen      = $false
+                }
+            )
+        #>
         $atpPolicyResult = Get-CISExoOutput -Rec $recnum
         if ($atpPolicyResult -ne 1) {
             try {
                 # Condition A: Check Safe Attachments for SharePoint
                 # Condition B: Check Safe Attachments for OneDrive
                 # Condition C: Check Safe Attachments for Microsoft Teams
-
                 # Determine the result based on the ATP policy settings
                 $result = $null -ne $atpPolicyResult
+                #$atpPolicyResult | Where-Object { $_.Identity -eq "Default" }
+                if ($result) {
+                    $detailpass = [PSCustomObject]@{
+                        Name                    = $atpPolicyResult.Name
+                        EnableATPForSPOTeamsODB = $atpPolicyResult.EnableATPForSPOTeamsODB
+                        EnableSafeDocs          = $atpPolicyResult.EnableSafeDocs
+                        AllowSafeDocsOpen       = $atpPolicyResult.AllowSafeDocsOpen
+                    }
+                    $detailsString = $detailpass | ForEach-Object {
+                        @"
+Name: $($_.Name)
+EnableATPForSPOTeamsODB: $($_.EnableATPForSPOTeamsODB)
+EnableSafeDocs: $($_.EnableSafeDocs)
+AllowSafeDocsOpen: $($_.AllowSafeDocsOpen)
+`n
+"@
+                    }
+                }
                 $details = if ($result) {
-                    "ATP for SharePoint, OneDrive, and Teams is enabled with correct settings."
+                    $detailsString
                 }
                 else {
                     "ATP for SharePoint, OneDrive, and Teams is not enabled with correct settings."
                 }
-
                 $failureReasons = if ($result) {
                     "N/A"
                 }
                 else {
                     "ATP policy for SharePoint, OneDrive, and Microsoft Teams is not correctly configured."
                 }
-
                 # Create and populate the CISAuditResult object
                 $params = @{
                     Rec           = $recnum
@@ -66,13 +89,10 @@ function Test-SafeAttachmentsTeams {
             }
             catch {
                 Write-Error "An error occurred during the test: $_"
-
                 # 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
             }
@@ -88,7 +108,6 @@ function Test-SafeAttachmentsTeams {
             $auditResult = Initialize-CISAuditResult @params
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-SafeLinksOfficeApps.ps1

@@ -5,16 +5,14 @@ function Test-SafeLinksOfficeApps {
         # Aligned
         # Define your parameters here if needed
     )
-
     begin {
         # Dot source the class script if necessary
         #. .\source\Classes\CISAuditResult.ps1
         # Initialization code, if needed
         $recnum = "2.1.1"
-
+        Write-Verbose "Running Test-SafeLinksOfficeApps for $recnum..."
         <#
         Conditions for 2.1.1 (L2) Ensure Safe Links for Office Applications 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:
@@ -25,7 +23,6 @@ function Test-SafeLinksOfficeApps {
             - Click protection settings: On
             - Do not track when users click safe links: Off
           - Condition B: Using the Exchange Online PowerShell Module, Safe Links policies are retrieved, and the relevant policy shows Safe Links for Office applications is enabled.
-
         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:
@@ -38,7 +35,6 @@ function Test-SafeLinksOfficeApps {
           - Condition B: Using the Exchange Online PowerShell Module, Safe Links policies are retrieved, and the relevant policy shows Safe Links for Office applications is not enabled.
         #>
     }
-
     process {
         # 2.1.1 (L2) Ensure Safe Links for Office Applications is Enabled
         # Retrieve all Safe Links policies
@@ -49,9 +45,8 @@ function Test-SafeLinksOfficeApps {
                 # Prepare the final result
                 # Condition B: Ensuring no misconfigurations
                 $result = $misconfiguredDetails.Count -eq 0
-                $details = if ($result) { "All Safe Links policies are correctly configured." } else { $misconfiguredDetails -join ' | ' }
+                $details = if ($result) { "All Safe Links policies are correctly configured." } else { $misconfiguredDetails -join '`n' }
                 $failureReasons = if ($result) { "N/A" } else { "The following Safe Links policies settings do not meet the recommended configuration: $($misconfiguredDetails -join ' | ')" }
-
                 # Create and populate the CISAuditResult object
                 $params = @{
                     Rec           = $recnum
@@ -64,13 +59,10 @@ function Test-SafeLinksOfficeApps {
             }
             catch {
                 Write-Error "An error occurred during the test: $_"
-
                 # 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
             }
@@ -86,7 +78,6 @@ function Test-SafeLinksOfficeApps {
             $auditResult = Initialize-CISAuditResult @params
         }
     }
-
     end {
         # Return the audit result
         return $auditResult

source/tests/Test-SpamPolicyAdminNotify.ps1

@@ -1,78 +1,119 @@
 function Test-SpamPolicyAdminNotify {
     [CmdletBinding()]
     [OutputType([CISAuditResult])]
-    param (
-        # Aligned
-        # Parameters can be added if needed
-    )
-
+    param ()
     begin {
         # Dot source the class script if necessary
         #. .\source\Classes\CISAuditResult.ps1
         # Initialization code, if needed
-
-        $recnum = "2.1.6"
-
         <#
-        Conditions for 2.1.6 (L1) Ensure Exchange Online Spam Policies are set to notify administrators
-
-        Validate recommendation details:
-        - Confirm that the recommendation details are accurate and complete as per the CIS benchmark.
-
+            Conditions for 2.1.6 (L1) Ensure Exchange Online Spam Policies are set to notify administrators:
+            Description:
+                - This test ensures that Exchange Online Spam Policies are configured to notify administrators when a sender in the organization has been blocked for sending spam. It checks for the proper setup of both Bcc and Notify properties and the inclusion of valid email addresses.
             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 Security & Compliance Center, the Exchange Online Spam Policies are set to notify administrators when a sender in the organization has been blocked for sending spam emails.
-          - Condition B: Using PowerShell, the `NotifyOutboundSpam` and `NotifyOutboundSpamContact` properties are correctly set in all relevant spam filter policies.
-
+                - Checks that the 'BccSuspiciousOutboundMail' and 'NotifyOutboundSpam' properties are enabled for the default policy.
+                - Ensures that valid email addresses are provided for 'NotifyOutboundSpamRecipients' and 'BccSuspiciousOutboundAdditionalRecipients'.
             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 Security & Compliance Center, the Exchange Online Spam Policies are not set to notify administrators when a sender in the organization has been blocked for sending spam emails.
-          - Condition B: Using PowerShell, the `NotifyOutboundSpam` and `NotifyOutboundSpamContact` properties are not correctly set in all relevant spam filter policies.
+            - If the default policy is not found, this is flagged as a critical compliance issue.
+            - The test fails if any of the following settings are incorrect:
+                - 'BccSuspiciousOutboundMail' is not enabled.
+                - 'NotifyOutboundSpam' is not enabled.
+                - 'NotifyOutboundSpamRecipients' does not contain at least one valid email address.
+                - 'BccSuspiciousOutboundAdditionalRecipients' does not contain at least one valid email address.
+            Note:
+            - While the primary focus is on the default policy, the function also retrieves and displays settings from additional policies that are not default, providing comprehensive insight into the organization's configuration. These additional policies are not used to determine the test's pass/fail status but are included in the details for informational purposes.
         #>
+        $recnum = "2.1.6"
+        Write-Verbose "Running Test-SpamPolicyAdminNotify for $recnum..."
     }
-
     process {
         try {
-            # 2.1.6 Ensure Exchange Online Spam Policies are set to notify administrators
-
-            # Retrieve the default hosted outbound spam filter policy
-            $hostedOutboundSpamFilterPolicy = Get-CISExoOutput -Rec $recnum
-
-            # Check if both settings are enabled (Condition A and Condition B for pass)
-            $bccSuspiciousOutboundMailEnabled = $hostedOutboundSpamFilterPolicy.BccSuspiciousOutboundMail
-            $notifyOutboundSpamEnabled = $hostedOutboundSpamFilterPolicy.NotifyOutboundSpam
-            $areSettingsEnabled = $bccSuspiciousOutboundMailEnabled -and $notifyOutboundSpamEnabled
-
-            # Prepare failure details if any setting is not enabled (Condition A and Condition B for fail)
-            $failureDetails = @()
-            if (-not $bccSuspiciousOutboundMailEnabled) {
-                $failureDetails += "BccSuspiciousOutboundMail is not enabled."
+            # Mock data representing multiple spam filter policies
+            <#
+                $spamPolicies = @(
+                    [PSCustomObject]@{
+                        Name                                       = "Default"
+                        IsDefault                                  = $true
+                        NotifyOutboundSpam                         = $false
+                        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"
                     }
-            if (-not $notifyOutboundSpamEnabled) {
-                $failureDetails += "NotifyOutboundSpam is not enabled."
+                )
+            #>
+            $spamPolicies = Get-CISExoOutput -Rec $recnum
+            $defaultPolicy = $spamPolicies | Where-Object { $_.IsDefault -eq $true }
+            $additionalPolicies = $spamPolicies | Where-Object { $_.IsDefault -eq $false }
+            $details = @()
+            $failureReasons = @()
+            # Check the default policy settings and format details
+            # Build the details string for the default policy
+            if ($defaultPolicy) {
+                $details += "Default Policy: $($defaultPolicy.Name)`n`n" +
+                "Bcc Suspicious Outbound Mail: $($defaultPolicy.BccSuspiciousOutboundMail)`n" +
+                "Notify Outbound Spam: $($defaultPolicy.NotifyOutboundSpam)`n" +
+                "Notify Emails: $($defaultPolicy.NotifyOutboundSpamRecipients -join ', ')`n" +
+                "Bcc Emails: $($defaultPolicy.BccSuspiciousOutboundAdditionalRecipients -join ', ')"
+                if (-not $defaultPolicy.BccSuspiciousOutboundMail) {
+                    $failureReasons += "BccSuspiciousOutboundMail should be enabled."
                 }
-
-            # Create an instance of CISAuditResult and populate it
+                if (-not $defaultPolicy.NotifyOutboundSpam) {
+                    $failureReasons += "NotifyOutboundSpam should be enabled."
+                }
+                if (-not $defaultPolicy.NotifyOutboundSpamRecipients) {
+                    $failureReasons += "NotifyOutboundSpamRecipients should have at least one valid email."
+                }
+                if (-not $defaultPolicy.BccSuspiciousOutboundAdditionalRecipients) {
+                    $failureReasons += "BccSuspiciousOutboundAdditionalRecipients should have at least one valid email."
+                }
+            }
+            else {
+                $failureReasons += "No default policy found. This is critical for compliance."
+            }
+            # Format additional policy details
+            foreach ($policy in $additionalPolicies) {
+                $details += "`n`nAdditional Policy: $($policy.Name)`n`n" +
+                "Bcc Suspicious Outbound Mail: $($policy.BccSuspiciousOutboundMail)`n" +
+                "Notify Outbound Spam: $($policy.NotifyOutboundSpam)`n" +
+                "Notify Emails: $($policy.NotifyOutboundSpamRecipients -join ', ')`n" +
+                "Bcc Emails: $($policy.BccSuspiciousOutboundAdditionalRecipients -join ', ')"
+            }
+            $result = $failureReasons.Count -eq 0
+            $detailsString = $details -join "`n"
+            $failureReasonsString = $failureReasons -join "`n"
+            # Create and populate the CISAuditResult object
             $params = @{
                 Rec           = $recnum
-                Result        = $areSettingsEnabled
-                Status        = if ($areSettingsEnabled) { "Pass" } else { "Fail" }
-                Details       = if ($areSettingsEnabled) { "Both BccSuspiciousOutboundMail and NotifyOutboundSpam are enabled." } else { $failureDetails -join ' ' }
-                FailureReason = if (-not $areSettingsEnabled) { "One or both spam policies are not set to notify administrators." } else { "N/A" }
+                Result        = $result
+                Status        = if ($result) { "Pass" } else { "Fail" }
+                Details       = $detailsString
+                FailureReason = if (-not $result) { $failureReasonsString } else { "All settings are correct based on the default policy." }
             }
             $auditResult = Initialize-CISAuditResult @params
         }
         catch {
-            $LastError = $_
-            $auditResult = Get-TestError -LastError $LastError -recnum $recnum
+            Write-Error "An error occurred during the test: $_"
+            $auditResult = Get-TestError -LastError $_ -recnum $recnum
         }
     }
-
     end {
-        # Return auditResult
+        # Return the audit result
         return $auditResult
     }
 }
-

source/tests/Test-TeamsExternalAccess.ps1

@@ -2,17 +2,16 @@ function Test-TeamsExternalAccess {
     [CmdletBinding()]
     [OutputType([CISAuditResult])]
     param (
-        # Aligned
-        # Parameters can be defined here if needed
+        [Parameter(Mandatory = $false, HelpMessage = "Specifies the approved federated domains for the audit. Accepts an array of allowed domain names.")]
+        [string[]]$ApprovedFederatedDomains
     )
-
     begin {
         # Dot source the class script if necessary
         # . .\source\Classes\CISAuditResult.ps1
         # Initialization code, if needed
         $recnum = "8.2.1"
+        Write-Verbose "Running Test-TeamsExternalAccess for $recnum..."
     }
-
     process {
         try {
             # 8.2.1 (L1) Ensure 'external access' is restricted in the Teams admin center
@@ -23,33 +22,60 @@ function Test-TeamsExternalAccess {
             #   - 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 = Get-CISMSTeamsOutput -Rec $recnum
-
-            $allowedDomainsLimited = $false
-            if ($externalAccessConfig.AllowFederatedUsers -and $externalAccessConfig.AllowedDomains -and $externalAccessConfig.AllowedDomains.AllowedDomain.Count -gt 0) {
-                $allowedDomainsLimited = $true
+            # $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-CISMSTeamsOutput -Rec $recnum
+            # Testing
+            #$externalAccessConfig.AllowedDomains = @("msn.com", "google.com")
+            #$externalAccessConfig.AllowTeamsConsumer = $false
+            #$externalAccessConfig.AllowPublicUsers = $false
+            #$externalAccessConfig.AllowFederatedUsers = $true
+            # The above is for testing and will be replaced with the actual values from the Teams PowerShell output in production.
+            $allowedDomainsLimited = $false
+            $allowedDomainsMatch = $false
+            $invalidDomains = @()
+            if ($externalAccessConfig.AllowFederatedUsers) {
+                if ($externalAccessConfig.AllowedDomains -ne 'AllowAllKnownDomains' -and $externalAccessConfig.AllowedDomains.Count -gt 0) {
+                    $allowedDomainsLimited = $true
+                    if ($ApprovedFederatedDomains) {
+                        $invalidDomains = $externalAccessConfig.AllowedDomains | Where-Object { $_ -notin $ApprovedFederatedDomains }
+                        if ($invalidDomains.Count -eq 0) {
+                            $invalidDomains = "None"
+                        }
+                        $allowedDomainsMatch = $invalidDomains.Count -eq 0
+                    }
+                }
             }
-
             # Check if the configurations are as recommended
-            $isCompliant = -not $externalAccessConfig.AllowTeamsConsumer -and -not $externalAccessConfig.AllowPublicUsers -and (-not $externalAccessConfig.AllowFederatedUsers -or $allowedDomainsLimited)
-
+            $isCompliant = -not $externalAccessConfig.AllowTeamsConsumer -and -not $externalAccessConfig.AllowPublicUsers -and (-not $externalAccessConfig.AllowFederatedUsers -or ($allowedDomainsLimited -and $allowedDomainsMatch))
             # Create an instance of CISAuditResult and populate it
             $params = @{
                 Rec           = $recnum
                 Result        = $isCompliant
                 Status        = if ($isCompliant) { "Pass" } else { "Fail" }
-                Details       = "AllowTeamsConsumer: $($externalAccessConfig.AllowTeamsConsumer); AllowPublicUsers: $($externalAccessConfig.AllowPublicUsers); AllowFederatedUsers: $($externalAccessConfig.AllowFederatedUsers); AllowedDomains limited: $allowedDomainsLimited"
-                FailureReason = if (-not $isCompliant) { "One or more external access configurations are not compliant." } else { "N/A" }
+                Details       = "AllowTeamsConsumer: $($externalAccessConfig.AllowTeamsConsumer); AllowPublicUsers: $($externalAccessConfig.AllowPublicUsers); AllowFederatedUsers: $($externalAccessConfig.AllowFederatedUsers); AllowedDomains limited: $allowedDomainsLimited; AllowedDomains match: $allowedDomainsMatch; Invalid Domains: $($invalidDomains -join ', ')"
+                FailureReason = if (-not $isCompliant) { "One or more external access configurations are not compliant. Invalid domains found: $($invalidDomains -join ', ')" } else { "N/A" }
             }
             $auditResult = Initialize-CISAuditResult @params
         }
@@ -58,7 +84,6 @@ function Test-TeamsExternalAccess {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return auditResult
         return $auditResult

source/tests/Test-TeamsExternalFileSharing.ps1

@@ -2,48 +2,65 @@ function Test-TeamsExternalFileSharing {
     [CmdletBinding()]
     [OutputType([CISAuditResult])]
     param (
-        # Aligned
-        # Parameters can be added here if needed
+        [Parameter(Mandatory = $false)]
+        [string[]]$ApprovedCloudStorageProviders
     )
-
     begin {
         # Dot source the class script if necessary
         # . .\source\Classes\CISAuditResult.ps1
         # Initialization code, if needed
         $recnum = "8.1.1"
+        Write-Verbose "Running Test-TeamsExternalFileSharing for $recnum..."
     }
-
     process {
         try {
             # 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
+            # Retrieve the current Teams client configuration
             $clientConfig = Get-CISMSTeamsOutput -Rec $recnum
-            $approvedProviders = @("AllowDropBox", "AllowBox", "AllowGoogleDrive", "AllowShareFile", "AllowEgnyte")
+            # Testing
+            #$clientconfig.AllowGoogleDrive = $false
+            #$clientconfig.AllowBox = $false
+            #$clientconfig.AllowShareFile = $false
+            #$clientconfig.AllowEgnyte = $false
+            #$clientconfig.AllowDropBox = $false
+            # Define all possible cloud storage providers
+            $allProviders = @("AllowDropBox", "AllowBox", "AllowGoogleDrive", "AllowShareFile", "AllowEgnyte")
+            # If ApprovedCloudStorageProviders is provided, map it to the corresponding settings
+            if ($PSBoundParameters.ContainsKey('ApprovedCloudStorageProviders')) {
+                $approvedProviders = @()
+                foreach ($provider in $ApprovedCloudStorageProviders) {
+                    $approvedProviders += "Allow$provider"
+                }
+            } else {
+                # Default approved providers
+                $approvedProviders = @()
+            }
             $isCompliant = $true
             $nonCompliantProviders = @()
-
-            foreach ($provider in $approvedProviders) {
-                if (-not $clientConfig.$provider) {
+            foreach ($provider in $allProviders) {
+                if ($clientConfig.$provider -and -not $approvedProviders.Contains($provider)) {
                     $isCompliant = $false
                     $nonCompliantProviders += $provider
                 }
             }
-
+            $basePassDetails = "All cloud storage services are approved providers"
+            if ($ApprovedCloudStorageProviders) {
+                $basePassDetails = "Approved cloud storage services: $($ApprovedCloudStorageProviders -join ', ')"
+            }
             # Create an instance of CISAuditResult and populate it
             $params = @{
                 Rec           = $recnum
                 Result        = $isCompliant
                 Status        = if ($isCompliant) { "Pass" } else { "Fail" }
-                Details       = if (-not $isCompliant) { "Non-approved providers enabled: $($nonCompliantProviders -join ', ')" } else { "All cloud storage services are approved providers" }
+                Details       = if (-not $isCompliant) { "Non-approved providers enabled: $($nonCompliantProviders -join ', ')" } else { $basePassDetails }
                 FailureReason = if (-not $isCompliant) { "The following non-approved providers are enabled: $($nonCompliantProviders -join ', ')" } else { "N/A" }
             }
             $auditResult = Initialize-CISAuditResult @params
@@ -53,7 +70,6 @@ function Test-TeamsExternalFileSharing {
             $auditResult = Get-TestError -LastError $LastError -recnum $recnum
         }
     }
-
     end {
         # Return auditResult
         return $auditResult

tests/Unit/Private/Get-PhishPolicyDetail.tests.ps1

@@ -0,0 +1,27 @@
+$ProjectPath = "$PSScriptRoot\..\..\.." | Convert-Path
+$ProjectName = ((Get-ChildItem -Path $ProjectPath\*\*.psd1).Where{
+        ($_.Directory.Name -match 'source|src' -or $_.Directory.Name -eq $_.BaseName) -and
+        $(try { Test-ModuleManifest $_.FullName -ErrorAction Stop } catch { $false } )
+    }).BaseName
+
+
+Import-Module $ProjectName
+
+InModuleScope $ProjectName {
+    Describe Get-PrivateFunction {
+        Context 'Default' {
+            BeforeEach {
+                $return = Get-PrivateFunction -PrivateData 'string'
+            }
+
+            It 'Returns a single object' {
+                ($return | Measure-Object).Count | Should -Be 1
+            }
+
+            It 'Returns a string based on the parameter PrivateData' {
+                $return | Should -Be 'string'
+            }
+        }
+    }
+}
+

tests/Unit/Private/Test-PhishPolicyCompliance.tests.ps1

@@ -0,0 +1,27 @@
+$ProjectPath = "$PSScriptRoot\..\..\.." | Convert-Path
+$ProjectName = ((Get-ChildItem -Path $ProjectPath\*\*.psd1).Where{
+        ($_.Directory.Name -match 'source|src' -or $_.Directory.Name -eq $_.BaseName) -and
+        $(try { Test-ModuleManifest $_.FullName -ErrorAction Stop } catch { $false } )
+    }).BaseName
+
+
+Import-Module $ProjectName
+
+InModuleScope $ProjectName {
+    Describe Get-PrivateFunction {
+        Context 'Default' {
+            BeforeEach {
+                $return = Get-PrivateFunction -PrivateData 'string'
+            }
+
+            It 'Returns a single object' {
+                ($return | Measure-Object).Count | Should -Be 1
+            }
+
+            It 'Returns a string based on the parameter PrivateData' {
+                $return | Should -Be 'string'
+            }
+        }
+    }
+}
+

tests/Unit/Public/Grant-M365SecurityAuditConsent.tests.ps1

@@ -0,0 +1,71 @@
+BeforeAll {
+    $script:moduleName = '<% $PLASTER_PARAM_ModuleName %>'
+
+    # If the module is not found, run the build task 'noop'.
+    if (-not (Get-Module -Name $script:moduleName -ListAvailable))
+    {
+        # Redirect all streams to $null, except the error stream (stream 2)
+        & "$PSScriptRoot/../../build.ps1" -Tasks 'noop' 2>&1 4>&1 5>&1 6>&1 > $null
+    }
+
+    # Re-import the module using force to get any code changes between runs.
+    Import-Module -Name $script:moduleName -Force -ErrorAction 'Stop'
+
+    $PSDefaultParameterValues['InModuleScope:ModuleName'] = $script:moduleName
+    $PSDefaultParameterValues['Mock:ModuleName'] = $script:moduleName
+    $PSDefaultParameterValues['Should:ModuleName'] = $script:moduleName
+}
+
+AfterAll {
+    $PSDefaultParameterValues.Remove('Mock:ModuleName')
+    $PSDefaultParameterValues.Remove('InModuleScope:ModuleName')
+    $PSDefaultParameterValues.Remove('Should:ModuleName')
+
+    Remove-Module -Name $script:moduleName
+}
+
+Describe Get-Something {
+
+    Context 'Return values' {
+        BeforeEach {
+            $return = Get-Something -Data 'value'
+        }
+
+        It 'Returns a single object' {
+            ($return | Measure-Object).Count | Should -Be 1
+        }
+
+    }
+
+    Context 'Pipeline' {
+        It 'Accepts values from the pipeline by value' {
+            $return = 'value1', 'value2' | Get-Something
+
+            $return[0] | Should -Be 'value1'
+            $return[1] | Should -Be 'value2'
+        }
+
+        It 'Accepts value from the pipeline by property name' {
+            $return = 'value1', 'value2' | ForEach-Object {
+                [PSCustomObject]@{
+                    Data = $_
+                    OtherProperty = 'other'
+                }
+            } | Get-Something
+
+
+            $return[0] | Should -Be 'value1'
+            $return[1] | Should -Be 'value2'
+        }
+    }
+
+    Context 'ShouldProcess' {
+        It 'Supports WhatIf' {
+            (Get-Command Get-Something).Parameters.ContainsKey('WhatIf') | Should -Be $true
+            { Get-Something -Data 'value' -WhatIf } | Should -Not -Throw
+        }
+
+
+    }
+}
+