NIST 800-53 control families and baseline selection (Low/Moderate/High)

version
0.1.0
GitHub stars
436

Install

/plugin install nist-800-53@grc-engineering-suite

Run it inside Claude Code after adding the marketplace with /plugin marketplace add GRCEngClub/claude-grc-engineering.

Contents

Discovered from source

Skills 1

NIST 800-53 Expert

Deep expertise in NIST Special Publication 800-53 controls.

Expertise Areas

Control Families (20 Families in Rev 5)

  • AC: Access Control
  • AT: Awareness and Training
  • AU: Audit and Accountability
  • CA: Assessment, Authorization, Monitoring
  • CM: Configuration Management
  • CP: Contingency Planning
  • IA: Identification and Authentication
  • IR: Incident Response
  • MA: Maintenance
  • MP: Media Protection
  • PE: Physical/Environmental Protection
  • PL: Planning
  • PM: Program Management
  • PS: Personnel Security
  • PT: PII Processing and Transparency
  • RA: Risk Assessment
  • SA: System/Services Acquisition
  • SC: System/Communications Protection
  • SI: System/Information Integrity
  • SR: Supply Chain Risk Management

Baselines

  • Low Impact: ~125 controls
  • Moderate Impact: ~325 controls
  • High Impact: ~425 controls

Capabilities

  • Baseline selection guidance
  • Control tailoring recommendations
  • Parameter assignment assistance
  • Overlay application (privacy, cloud)
  • FedRAMP alignment mapping
  • Assessment procedure guidance

Commands 8

NIST 800-53 Assessment

Evaluates compliance against NIST 800-53 control families.

Arguments

  • $1 - Control family or baseline (required: AC, AT, AU, etc. or low, moderate, high)
  • $2 - Revision (optional: r4, r5, defaults to r5)

Control Families

IDFamily
ACAccess Control
ATAwareness and Training
AUAudit and Accountability
CAAssessment, Authorization, and Monitoring
CMConfiguration Management
CPContingency Planning
IAIdentification and Authentication
IRIncident Response
MAMaintenance
MPMedia Protection
PEPhysical and Environmental Protection
PLPlanning
PMProgram Management
PSPersonnel Security
PTPII Processing and Transparency
RARisk Assessment
SASystem and Services Acquisition
SCSystem and Communications Protection
SISystem and Information Integrity
SRSupply Chain Risk Management

Example

/nist:assess moderate
/nist:assess AC r5

NIST 800-53 Continuous Monitoring Setup

Establishes comprehensive continuous monitoring program compliant with NIST 800-53 requirements (RA-5, SI-4, CA-7), including vulnerability scanning, security event monitoring, configuration management, and automated reporting for FedRAMP and other authorizations.

Usage

/nist:continuous-monitoring-setup [program-type] [options]

Arguments

  • $1 - Program type (optional): "fedramp", "fisma", "standard" (default: "standard")
  • $2 - Options (optional): --environment=cloud|hybrid, --auto-deploy, --skip-fedramp-reports

Examples

# Set up standard NIST 800-53 continuous monitoring
/nist:continuous-monitoring-setup standard

# Set up FedRAMP continuous monitoring (monthly reports)
/nist:continuous-monitoring-setup fedramp

# Auto-deploy monitoring stack
/nist:continuous-monitoring-setup fedramp --auto-deploy

# Cloud-only monitoring (skip on-prem tools)
/nist:continuous-monitoring-setup standard --environment=cloud

Output

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
NIST 800-53 CONTINUOUS MONITORING SETUP
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Program Type: FedRAMP Continuous Monitoring
Environment: Cloud (AWS)
Compliance Requirements:
  - NIST 800-53 Rev 5
  - FedRAMP Moderate Baseline
  - Monthly deliverables to FedRAMP PMO

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PHASE 1: VULNERABILITY SCANNING (RA-5)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

NIST Requirement:
  RA-5: The organization scans for vulnerabilities in the information system
        and hosted applications [Assignment: organization-defined frequency
        and/or randomly in accordance with organization-defined process].

  RA-5(1): Employ vulnerability scanning tools that include the capability to
           readily update the list of information system vulnerabilities.

  RA-5(2): Update the list of information system vulnerabilities scanned prior
           to a new scan.

  RA-5(5): Implement privileged access authorization to [Assignment:
           organization-defined information system components] for selected
           vulnerability scanning activities.

FedRAMP Requirement:
  - Monthly vulnerability scans (authenticated/credentialed)
  - All assets must be scanned
  - Report submitted to FedRAMP within 30 days
  - POA&M for any findings >30 days old

Implementation:

Step 1: Deploy Vulnerability Scanning Tool

  Option A: Amazon Inspector (AWS Native - RECOMMENDED)
    ✓ Pros: Native integration, agent-based, continuous scanning
    ✓ Cons: AWS-only, requires SSM agent

    Deployment:
    ```bash
    # Enable Inspector in all regions
    aws inspector2 enable --resource-types EC2 ECR LAMBDA

    # Deploy SSM agent to EC2 instances
    aws ssm create-association \
      --name "AWS-ConfigureAWSPackage" \
      --targets "Key=instanceids,Values=*" \
      --parameters '{"action":["Install"],"name":["AmazonInspector"]}'

    # Configure automated findings export
    aws inspector2 create-findings-report \
      --report-format JSON \
      --s3-destination bucketName=compliance-reports
    ```

    Cost: $0.09/instance/month + $0.01/scan for Lambda

  Option B: Tenable.io (Industry Standard)
    ✓ Pros: FedRAMP authorized, comprehensive coverage, widely accepted by 3PAOs
    ✓ Cons: Additional cost, requires credential management

    Deployment:
    ```bash
    # Deploy Tenable Cloud Connector
    # (Terraform module provided)
    terraform apply -target=module.tenable_connector
    ```

    Cost: $2,500/year (up to 65 assets)

  Option C: Qualys VMDR
    ✓ Pros: FedRAMP authorized, cloud agent-based, dashboard
    ✓ Cons: Cost

    Cost: $1,995/year (up to 100 assets)

  RECOMMENDATION: Use Inspector for continuous scanning + Tenable for monthly
                  FedRAMP scans (3PAO accepts Tenable reports)

Step 2: Configure Authenticated Scanning (RA-5(5))

  AWS Inspector:
    - Uses SSM agent (already has credentialed access)
    - Automatically scans packages, network reachability, CVEs
    - No additional credential configuration needed

  Tenable:
    - Create read-only IAM user: tenable-scanner
    - Grant permissions: ec2:Describe*, ssm:Describe*, rds:Describe*
    - Store credentials in Tenable Cloud

    ```bash
    # Create scanner IAM user
    aws iam create-user --user-name tenable-scanner
    aws iam attach-user-policy --user-name tenable-scanner \
      --policy-arn arn:aws:iam::aws:policy/SecurityAudit

    # Create access key (store securely in Tenable)
    aws iam create-access-key --user-name tenable-scanner
    ```

Step 3: Schedule Monthly Scans (FedRAMP Requirement)

  EventBridge Rule: monthly-vulnerability-scan
    - Schedule: First Monday of each month, 2 AM UTC
    - Target: Lambda function → trigger Tenable scan
    - Notification: Email to security team when scan starts

    ```bash
    aws events put-rule \
      --name monthly-vulnerability-scan \
      --schedule-expression "cron(0 2 ? * 2#1 *)" \
      --description "Monthly FedRAMP vuln scan"

    aws events put-targets \
      --rule monthly-vulnerability-scan \
      --targets "Id"="1","Arn"="<lambda-arn>"
    ```

Step 4: Automated Vulnerability Remediation

  Critical/High Vulnerabilities:
    - Automated patching via SSM Patch Manager
    - Patch within 30 days (FedRAMP requirement)
    - Exceptions documented in POA&M

    ```bash
    # Create patch baseline
    aws ssm create-patch-baseline \
      --name "FedRAMP-Patch-Baseline" \
      --approval-rules "PatchRules=[{PatchFilterGroup={PatchFilters=[{Key=CLASSIFICATION,Values=[Security]}]},ApproveAfterDays=7}]"

    # Schedule automated patching (weekly)
    aws ssm create-maintenance-window \
      --name "Weekly-Security-Patching" \
      --schedule "cron(0 3 ? * SUN *)" \
      --duration 4 \
      --cutoff 1
    ```

Step 5: Vulnerability Reporting

  Monthly FedRAMP Deliverable:
    - Scan report (all findings)
    - Remediation summary
    - POA&M for open items >30 days

    Generated automatically:
    ```bash
    # Lambda function: generate-fedramp-vuln-report
    # Triggers: 5th of each month
    # Outputs: PDF report to S3, email to FedRAMP PMO
    ```

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PHASE 2: SECURITY EVENT MONITORING (SI-4)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

NIST Requirement:
  SI-4: The organization monitors the information system to detect attacks
        and indicators of potential attacks in accordance with [Assignment:
        organization-defined monitoring objectives]; and unauthorized local,
        network, and remote connections.

  SI-4(2): Employ automated tools to support near real-time analysis of events.

  SI-4(4): Monitor inbound and outbound communications traffic continuously for
           unusual or unauthorized activities or conditions.

  SI-4(5): Alert [Assignment: organization-defined personnel or roles] when
           indications of compromises or potential compromises occur.

FedRAMP Requirement:
  - 24/7 continuous monitoring
  - Incident reporting to FedRAMP within 1 hour (high severity)
  - Monthly security metrics

Implementation:

Step 1: Enable Core Monitoring Services

  AWS GuardDuty (Threat Detection):
    ```bash
    # Enable GuardDuty in all regions
    aws guardduty create-detector --enable

    # Enable S3 protection
    aws guardduty update-detector \
      --detector-id <detector-id> \
      --data-sources '{"S3Logs":{"Enable":true}}'

    # Export findings to S3 for long-term retention
    aws guardduty create-publishing-destination \
      --detector-id <detector-id> \
      --destination-type S3 \
      --destination-properties DestinationArn=arn:aws:s3:::security-findings
    ```

    Cost: $4.50/month per AWS account + $1.00/GB traffic analyzed

  AWS Security Hub (Aggregation):
    ```bash
    # Enable Security Hub
    aws securityhub enable-security-hub

    # Enable standards
    aws securityhub batch-enable-standards \
      --standards-subscription-requests \
        StandardsArn="arn:aws:securityhub:us-east-1::standards/aws-foundational-security-best-practices/v/1.0.0" \
        StandardsArn="arn:aws:securityhub:us-east-1::standards/cis-aws-foundations-benchmark/v/1.2.0"

    # Aggregate findings from Inspector, GuardDuty, Macie, Config
    ```

    Cost: $0.0010 per security check per region per month

  AWS CloudWatch (Metrics & Logs):
    ```bash
    # Create log groups for application logs
    aws logs create-log-group --log-group-name /aws/lambda/app
    aws logs put-retention-policy --log-group-name /aws/lambda/app --retention-in-days 365

    # Create metric filters for security events
    aws logs put-metric-filter \
      --log-group-name /aws/cloudtrail \
      --filter-name "UnauthorizedAPICalls" \
      --filter-pattern '[... , eventName, errorCode=*UnauthorizedOperation||errorCode=AccessDenied*]' \
      --metric-transformations \
        metricName=UnauthorizedAPICalls,metricNamespace=CloudTrailMetrics,metricValue=1
    ```

Step 2: Configure Real-Time Alerting (SI-4(5))

  Critical Alerts (PagerDuty Integration):
    - GuardDuty HIGH severity findings
    - Unauthorized API calls (multiple in 5 minutes)
    - Root account usage
    - Security group changes allowing 0.0.0.0/0
    - IAM policy changes (administrative actions)

    ```bash
    # EventBridge rule for GuardDuty high findings
    aws events put-rule \
      --name guardduty-high-severity \
      --event-pattern '{
        "source": ["aws.guardduty"],
        "detail-type": ["GuardDuty Finding"],
        "detail": {
          "severity": [7, 7.9, 8, 8.9]
        }
      }'

    # Target: Lambda → PagerDuty API
    aws events put-targets \
      --rule guardduty-high-severity \
      --targets "Id"="1","Arn"="<pagerduty-lambda-arn>"
    ```

  Medium Alerts (Slack Notification):
    - GuardDuty MEDIUM findings
    - Config compliance changes
    - Unusual API activity

    ```bash
    # EventBridge rule for medium findings
    # Target: SNS → Slack webhook
    ```

  Low/Info (Email Digest):
    - Daily summary of all findings
    - Weekly trend analysis
    - Monthly security metrics

Step 3: Network Traffic Monitoring (SI-4(4))

  VPC Flow Logs:
    ```bash
    # Enable flow logs for all VPCs
    aws ec2 create-flow-logs \
      --resource-type VPC \
      --resource-ids <vpc-id> \
      --traffic-type ALL \
      --log-destination-type s3 \
      --log-destination arn:aws:s3:::vpc-flow-logs \
      --max-aggregation-interval 60

    # Analyze flow logs for anomalies
    # (Athena queries or GuardDuty VPC flow log analysis)
    ```

  Network Intrusion Detection (optional):
    - Deploy AWS Network Firewall with IDS/IPS
    - Or use third-party NIDS (Suricata, Zeek)

    Cost: $0.395/hour per endpoint (~$285/month)

Step 4: Centralized SIEM (Optional but Recommended)

  Option A: Splunk Cloud (FedRAMP Authorized)
    - Ingests CloudTrail, GuardDuty, flow logs, application logs
    - Correlation rules for advanced threat detection
    - FedRAMP reporting dashboards

    Cost: $150-$300/GB ingested per month
    Typical: 50 GB/month = $7,500-$15,000/month

  Option B: Datadog Security Monitoring
    - Native AWS integration
    - Real-time threat detection
    - Compliance dashboards

    Cost: $15/host/month + $0.10/GB logs

  Option C: AWS-Native Stack (Cost-Effective)
    - CloudWatch Logs Insights for queries
    - Athena for analysis of S3-stored logs
    - QuickSight for dashboards

    Cost: $100-$500/month

  RECOMMENDATION: AWS-native for small deployments, Splunk for FedRAMP

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PHASE 3: CONFIGURATION MANAGEMENT (CM-3, CM-6)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

NIST Requirement:
  CM-3: The organization tracks, reviews, approves/disapproves, and audits
        changes to the information system.

  CM-6: The organization establishes and documents mandatory configuration
        settings for information technology products employed.

FedRAMP Requirement:
  - Monthly change report to FedRAMP PMO
  - Significant changes require pre-approval

Implementation:

Step 1: Enable AWS Config

  ```bash
  # Create Config recorder
  aws configservice put-configuration-recorder \
    --configuration-recorder name=default,roleARN=<config-role-arn>

  # Create delivery channel
  aws configservice put-delivery-channel \
    --delivery-channel name=default,s3BucketName=config-logs

  # Start recording
  aws configservice start-configuration-recorder --configuration-recorder-name default

Step 2: Deploy Compliance Rules

FedRAMP-Required Config Rules: - iam-user-mfa-enabled - root-account-mfa-enabled - s3-bucket-public-read-prohibited - s3-bucket-public-write-prohibited - encrypted-volumes - rds-encryption-enabled - cloudtrail-enabled - multi-region-cloudtrail-enabled - access-keys-rotated (90 days)

```bash
# Deploy conformance pack (bundle of rules)
aws configservice put-conformance-pack \
  --conformance-pack-name "FedRAMP-Moderate" \
  --template-s3-uri s3://config-templates/fedramp-moderate.yaml
```

Step 3: Change Tracking and Approval

Infrastructure Changes (Terraform): - All changes via pull request - Terraform plan reviewed by security team - Approved changes merged to main - CI/CD applies changes automatically

Evidence: GitHub pull request history, Terraform Cloud run logs

Configuration Changes (AWS Console): - Detected by Config - EventBridge rule triggers notification - Security team reviews change - Unapproved changes rolled back automatically

```bash
# Detect manual console changes
aws events put-rule \
  --name detect-manual-changes \
  --event-pattern '{
    "source": ["aws.config"],
    "detail-type": ["Config Configuration Item Change"],
    "detail": {
      "configurationItemDiff": {
        "changeType": ["CREATE", "UPDATE"]
      }
    }
  }'
```

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ PHASE 4: CONTINUOUS MONITORING METRICS (CA-7) ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

NIST Requirement: CA-7: The organization develops a continuous monitoring strategy and implements a continuous monitoring program that includes metrics, assessments, and ongoing authorizations.

CA-7(1): Employ independent assessors or assessment teams to monitor the security controls in the information system on an ongoing basis.

CA-7(3): Employ trend analyses to determine if security control implementations, the frequency of continuous monitoring activities, and/or the types of activities used in the continuous monitoring process need to be modified based on empirical data.

FedRAMP Requirement:

  • Monthly deliverables (vulnerability scan, POA&M, change log, incidents)
  • Annual assessment by 3PAO
  • Quarterly self-assessment

Implementation:

Monthly FedRAMP Deliverables:

  1. Vulnerability Scan Report

    • Generated: 5th of each month
    • Source: Tenable/Inspector
    • Format: PDF + CSV
    • Upload: FedRAMP Secure Repository (FSR)
  2. Plan of Action & Milestones (POA&M)

    • All open findings
    • Status updates
    • Remediation timeline
    • Risk ratings
  3. Incident Summary

    • All P1/P2 incidents
    • Root cause analysis
    • Remediation actions
    • Lessons learned
  4. Change Log

    • All significant changes (architecture, new services)
    • Change approval evidence
    • Rollback plans
  5. Inventory Updates

    • New/decommissioned assets
    • Software updates
    • Third-party integrations

Automated Report Generation:

# Lambda function: generate-monthly-fedramp-package
# Schedule: 1st of each month
# Actions:
#   1. Collect vulnerability scan results
#   2. Export POA&M from Jira
#   3. Export incident summary from PagerDuty
#   4. Export change log from GitHub + Terraform Cloud
#   5. Export asset inventory from Config
#   6. Generate PDF package
#   7. Upload to FSR
#   8. Email confirmation to FedRAMP PMO

Continuous Monitoring Dashboard:

CloudWatch Dashboard: fedramp-continuous-monitoring

Widgets: - Vulnerability Count (by severity) - GuardDuty Findings (30-day trend) - Config Compliance Score (%) - Patch Compliance (%) - Mean Time to Remediate (days) - Incident Count (by month) - Change Frequency (changes per month)

# Create dashboard
aws cloudwatch put-dashboard \
  --dashboard-name fedramp-continuous-monitoring \
  --dashboard-body file://dashboard.json

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ DEPLOYMENT SUMMARY ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Automated Deployment:

# Clone monitoring templates
git clone https://github.com/your-org/continuous-monitoring-iac
cd continuous-monitoring-iac

# Configure environment
cp .env.example .env
# Edit .env with your AWS account, FedRAMP details

# Deploy infrastructure
terraform init
terraform plan
terraform apply

# Verify deployment
./scripts/verify-monitoring.sh

What Gets Deployed:

✓ Vulnerability Scanning:

  • Amazon Inspector (continuous)
  • Tenable Cloud Connector (monthly)
  • SSM Patch Manager (automated patching)
  • EventBridge rules (scan scheduling)

✓ Security Monitoring:

  • GuardDuty (threat detection)
  • Security Hub (aggregation)
  • CloudWatch Logs (365-day retention)
  • VPC Flow Logs
  • CloudTrail (multi-region)

✓ Configuration Management:

  • AWS Config (all regions)
  • FedRAMP compliance rules (20+ rules)
  • Change detection and alerting

✓ Alerting and Reporting:

  • PagerDuty integration (critical alerts)
  • Slack webhooks (medium alerts)
  • Email notifications (daily digest)
  • Monthly FedRAMP report automation

✓ Dashboards:

  • CloudWatch dashboard (real-time metrics)
  • QuickSight dashboard (trend analysis, optional)

Deployment Time: 2-3 hours (automated), 1 day (manual) Cost: $500-$2,000/month (depending on data volume, SIEM choice)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ POST-DEPLOYMENT CHECKLIST ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

□ Verify all monitoring services enabled (Inspector, GuardDuty, Config) □ Confirm SSM agents deployed to all EC2 instances □ Test vulnerability scan (run manual scan, verify results) □ Validate alerts (trigger test alert, confirm PagerDuty/Slack notification) □ Review GuardDuty findings (address any immediate issues) □ Configure FedRAMP report automation (set up FSR upload) □ Schedule first monthly report (mark calendar) □ Document monitoring procedures (runbooks for alerts) □ Train security team (how to respond to alerts) □ Schedule quarterly self-assessment □ Schedule annual 3PAO assessment

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ COST SUMMARY ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Monthly Recurring Costs:

Vulnerability Scanning: Amazon Inspector: $50-$200 (depends on instances) Tenable.io: $200 (~$2,400/year)

Security Monitoring: GuardDuty: $300-$500 (depends on traffic) Security Hub: $50 CloudWatch Logs: $100-$300 (depends on volume) VPC Flow Logs storage: $50

Optional SIEM: Splunk Cloud: $7,500-$15,000 Datadog: $1,500-$3,000 AWS-native (CloudWatch): $200-$500

Alerting: PagerDuty: $200

Configuration Management: AWS Config: $100-$200

Total (Basic): $1,000-$1,500/month Total (with SIEM): $8,500-$16,500/month

Recommended: Start with AWS-native ($1,000/month), upgrade to SIEM if needed

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ COMPLIANCE VALIDATION ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Test Continuous Monitoring:

# Test vulnerability scanning
/grc-engineer:test-control RA-5

# Test security monitoring
/grc-engineer:test-control SI-4

# Test configuration management
/grc-engineer:test-control CM-3

# Test continuous monitoring program
/grc-engineer:test-control CA-7

Expected Results: ✓ RA-5: Vulnerability scans scheduled monthly, last scan <30 days ✓ SI-4: GuardDuty enabled, findings exported, alerts configured ✓ CM-3: Config enabled, change detection working, manual changes detected ✓ CA-7: Metrics collected, dashboards functioning, reports generated


## Related Commands

- `/nist:control-tailor` - Tailor monitoring controls
- `/nist:overlay-apply` - Apply FedRAMP overlay
- `/grc-engineer:test-control` - Test monitoring effectiveness
- `/grc-engineer:monitor-continuous` - General continuous monitoring

NIST 800-53 Control Tailoring

Provides interactive control tailoring guidance for NIST 800-53 baselines, helping organizations customize controls based on risk assessment, operational requirements, and technology constraints while maintaining compliance.

Usage

/nist:control-tailor <control-id> <baseline> [options]

Arguments

  • $1 - Control ID (e.g., "AC-2", "AU-2", "SC-7") or family (e.g., "AC", "AU")
  • $2 - Baseline: "low", "moderate", "high", "privacy"
  • $3 - Options (optional): --environment=cloud|hybrid|on-prem, --output=guidance|ssp-text|yaml

Examples

# Tailor single control for moderate baseline
/nist:control-tailor AC-2 moderate

# Tailor control for cloud environment
/nist:control-tailor AC-2 moderate --environment=cloud

# Tailor entire control family
/nist:control-tailor AC moderate

# Generate SSP-ready text
/nist:control-tailor SC-7 high --output=ssp-text

# Export tailoring decisions as YAML
/nist:control-tailor AC-2 moderate --output=yaml

Output

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
NIST 800-53 CONTROL TAILORING
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Control: AC-2 - Account Management
Baseline: Moderate
Environment: Cloud (AWS)
Organization: Your Company

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
BASELINE CONTROL STATEMENT (Rev 5)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

AC-2: Account Management

The organization:
  a. Identifies and selects the following types of information system accounts
     to support organizational missions/business functions: [Assignment: organization-
     defined information system account types];

  b. Assigns account managers for information system accounts;

  c. Establishes conditions for group and role membership;

  d. Specifies authorized users of the information system, group and role membership,
     and access authorizations (i.e., privileges) and other attributes (as required)
     for each account;

  e. Requires approvals by [Assignment: organization-defined personnel or roles]
     for requests to create information system accounts;

  f. Creates, enables, modifies, disables, and removes information system accounts
     in accordance with [Assignment: organization-defined procedures or conditions];

  g. Monitors the use of information system accounts;

  h. Notifies account managers when accounts are no longer required or when users
     are terminated or transferred;

  i. Authorizes access to the information system based on a valid access authorization,
     intended system usage, and other attributes as required;

  j. Reviews accounts for compliance with account management requirements
     [Assignment: organization-defined frequency]; and

  k. Establishes a process for reissuing shared/group account credentials when
     individuals are removed from the group.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CONTROL ENHANCEMENTS (Select for Moderate Baseline)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Baseline Includes:
✓ AC-2(1) - Automated System Account Management
✓ AC-2(2) - Removal of Temporary / Emergency Accounts
✓ AC-2(3) - Disable Inactive Accounts
✓ AC-2(4) - Automated Audit Actions
✓ AC-2(5) - Inactivity Logout
✓ AC-2(13) - Disable Accounts for High-Risk Individuals

Additional Enhancements Available (Optional):
□ AC-2(6) - Dynamic Privilege Management
□ AC-2(7) - Privileged User Accounts
□ AC-2(8) - Dynamic Account Creation
□ AC-2(9) - Restrictions on Use of Shared Groups / Accounts
□ AC-2(11) - Usage Conditions
□ AC-2(12) - Account Monitoring / Atypical Usage

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
RECOMMENDED ENHANCEMENTS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Based on: Cloud environment, Financial services sector, PCI-DSS overlap

STRONGLY RECOMMENDED (High ROI):

✓ AC-2(1) - Automated System Account Management
  Impact: HIGH
  Cost: MEDIUM
  Justification:
    - Reduces manual errors in provisioning/deprovisioning
    - Ensures timely access removal (compliance requirement)
    - Provides audit trail for all account changes
  Cloud Implementation:
    - AWS: IAM + Identity Center + Lambda for automation
    - Azure: Azure AD + PIM + Logic Apps
    - GCP: Cloud Identity + Workflows
  Effort: 40 hours (initial setup), 2 hours/month (maintenance)
  Satisfies: SOC2 CC6.1, PCI 8.1.4, ISO 27001 A.9.2

✓ AC-2(2) - Removal of Temporary / Emergency Accounts
  Impact: HIGH
  Cost: LOW
  Justification:
    - Prevents forgotten emergency accounts from becoming security risk
    - Required for high-sensitivity environments
    - Easy to implement with automation
  Cloud Implementation:
    - EventBridge rule to check account age
    - Lambda to disable accounts older than 72 hours
    - SNS notification before auto-disable
  Effort: 8 hours (one-time setup)
  Satisfies: ISO 27001 A.9.2.6

✓ AC-2(3) - Disable Inactive Accounts
  Impact: HIGH
  Cost: LOW
  Justification:
    - Reduces attack surface (inactive accounts = security risk)
    - Required for PCI-DSS compliance (90 days)
    - Aligns with SOC 2 best practices
  Cloud Implementation:
    - IAM credential report analysis
    - Automated disable after 90 days inactivity
    - Manager notification before disable
  Effort: 12 hours
  Satisfies: PCI 8.1.4, SOC2 CC6.1

✓ AC-2(4) - Automated Audit Actions
  Impact: HIGH
  Cost: MEDIUM
  Justification:
    - Creates audit trail for all account management
    - Enables security analytics and threat detection
    - Required for forensics and incident response
  Cloud Implementation:
    - CloudTrail for all IAM API calls
    - CloudWatch Logs with 1-year retention
    - GuardDuty for anomaly detection
  Effort: 16 hours
  Satisfies: SOC2 CC7.2, PCI 10.2

RECOMMENDED (Good Value):

⊕ AC-2(9) - Restrictions on Use of Shared Groups / Accounts
  Impact: MEDIUM
  Cost: LOW
  Justification:
    - Improves accountability (no shared accounts)
    - Best practice for access control
    - Easy to implement in cloud (IAM users are naturally unique)
  Cloud Implementation:
    - Policy: Prohibit shared IAM users
    - Service accounts documented and approved
    - Automated check via Config rule
  Effort: 4 hours
  Satisfies: PCI 8.1, SOC2 CC6.1

⊕ AC-2(12) - Account Monitoring / Atypical Usage
  Impact: MEDIUM
  Cost: MEDIUM
  Justification:
    - Detects compromised accounts
    - Enables proactive security response
    - Complements existing monitoring
  Cloud Implementation:
    - GuardDuty for anomaly detection
    - CloudWatch anomaly detection
    - SIEM integration (Splunk, DataDog)
  Effort: 24 hours
  Satisfies: NIST IR family

OPTIONAL (Consider for High Baseline Only):

○ AC-2(6) - Dynamic Privilege Management
  Impact: LOW
  Cost: HIGH
  Justification:
    - Complex to implement and maintain
    - Benefits limited unless handling very sensitive data
    - Better suited for zero-trust architectures
  Cloud Implementation: Difficult (requires custom PAM solution)
  Effort: 200+ hours
  Skip unless: Handling classified data, DoD requirements

○ AC-2(7) - Privileged User Accounts
  Impact: MEDIUM
  Cost: MEDIUM
  Justification:
    - Adds overhead (separate privileged accounts)
    - Cloud IAM roles provide similar separation
    - Not required for moderate baseline
  Cloud Implementation: Separate admin IAM users (not federated)
  Effort: 16 hours
  Consider if: Banking/finance, healthcare PHI

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
TAILORING DECISIONS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Organization-Defined Parameters:

[Assignment: organization-defined information system account types]
TAILORED TO:
  - Individual user accounts (workforce - federated via Okta)
  - Service accounts (applications - IAM roles)
  - Emergency access accounts (break-glass - max 72 hours)
  - Contractor accounts (temporary - max 6 months)

JUSTIFICATION: Cloud-only environment uses federated SSO for workforce
              and IAM roles for services, reducing account sprawl.

[Assignment: organization-defined personnel or roles]
TAILORED TO:
  - Standard accounts: Direct manager approval
  - Privileged accounts: CISO approval + manager approval
  - Service accounts: Application owner + Security team approval
  - Emergency accounts: CISO approval only

JUSTIFICATION: Aligns with organizational structure and risk tolerance.

[Assignment: organization-defined procedures or conditions]
TAILORED TO:
  - Automated provisioning via Okta/AWS SSO upon manager approval
  - Automated deprovisioning within 4 hours of HR termination
  - Quarterly access reviews by resource owners
  - Immediate disable for high-risk terminations (security incidents)

JUSTIFICATION: Automation reduces errors, improves timeliness.

[Assignment: organization-defined frequency]
TAILORED TO:
  - Quarterly reviews for all accounts (PCI requirement)
  - Monthly reviews for privileged accounts
  - Daily automated checks for inactive accounts (>90 days)

JUSTIFICATION: More restrictive than annual baseline requirement due to
              PCI-DSS overlap and cloud environment rapid changes.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
IMPLEMENTATION GUIDANCE (Cloud-Specific)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

AWS Implementation:

Account Types:
  ✓ Individual: AWS SSO federated users (via Okta)
  ✓ Service: IAM roles (for EC2, Lambda, ECS)
  ✓ Emergency: IAM users with MFA (disabled by default)

Automated Management (AC-2(1)):
  - Lambda function: sync-okta-to-sso
    Trigger: Okta webhook on user create/update/delete
    Action: Provision/update/deprovision AWS SSO user
    Evidence: CloudTrail logs of IAM::CreateUser events

Temporary Account Removal (AC-2(2)):
  - EventBridge rule: check-emergency-accounts
    Schedule: Daily at 9 AM UTC
    Action: Disable accounts with tag "Type=Emergency" older than 72h
    Evidence: Lambda execution logs

Inactive Account Detection (AC-2(3)):
  - Lambda function: check-inactive-accounts
    Schedule: Daily
    Logic: IAM credential report, last login > 90 days
    Action: Send warning email, disable after 7 days
    Evidence: S3 bucket with credential reports

Audit Logging (AC-2(4)):
  - CloudTrail: All IAM API calls
  - CloudWatch Logs: 365-day retention
  - S3: Long-term archive (3 years)
  - GuardDuty: Anomaly detection
  Evidence: CloudTrail event history

Azure Implementation:

Account Types:
  ✓ Individual: Azure AD users (federated via Okta)
  ✓ Service: Managed identities
  ✓ Emergency: Break-glass accounts (cloud-only, PIM)

Automated Management (AC-2(1)):
  - Logic Apps: Sync Okta to Azure AD
  - PIM: Just-in-time privileged access
  - Lifecycle workflows: Automated provisioning/deprovisioning

GCP Implementation:

Account Types:
  ✓ Individual: Cloud Identity (federated)
  ✓ Service: Service accounts
  ✓ Emergency: Break-glass accounts

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
TAILORED CONTROL STATEMENT (SSP-Ready)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

What Responsible: Information Security, IT Operations
What Implemented: January 2024

AC-2: Account Management

Your Company manages information system accounts through automated provisioning
integrated with our HR system (BambooHR) and identity provider (Okta). The
organization maintains the following account types:

  a. Account Types:
     - Workforce accounts (federated via Okta to AWS SSO)
     - Service accounts (AWS IAM roles for applications)
     - Emergency access accounts (break-glass, disabled by default, max 72 hours)
     - Contractor accounts (temporary, max 6 months)

  b. Account managers are assigned based on organizational structure:
     - IT Operations manages workforce accounts
     - Application teams manage service accounts
     - CISO manages emergency access accounts

  c. Group and role membership is established based on job function using role-based
     access control (RBAC). Roles are documented in the Access Control Policy v1.8.

  d. Authorized users, group membership, and privileges are specified in Okta and
     automatically synchronized to AWS SSO. Access authorizations are documented
     in access request tickets (Jira Service Desk).

  e. Account creation approvals:
     - Standard accounts: Direct manager approval via Jira
     - Privileged accounts: Manager + CISO approval
     - Service accounts: Application owner + Security team approval

  f. Account lifecycle is managed through automated workflows:
     - Creation: Okta webhook triggers AWS SSO provisioning
     - Modification: Jira approval workflow + automated update
     - Disable: Automated within 4 hours of HR termination event
     - Removal: 90 days after disable (after verification)

  g. Account usage is monitored through:
     - CloudTrail (all IAM API activity)
     - GuardDuty (anomaly detection)
     - Daily credential report analysis (inactive accounts)

  h. Account managers are notified automatically:
     - HR termination event triggers immediate Slack/email notification
     - Quarterly access review lists include account manager
     - Inactive account warnings sent to managers 7 days before disable

  i. Access authorization is based on:
     - Valid Jira approval ticket
     - HR system confirmation of active employment
     - Okta group membership (synchronized from HR)
     - Least privilege principle (minimum necessary access)

  j. Accounts are reviewed quarterly (every 90 days) by resource owners and
     managers. Privileged accounts are reviewed monthly. Reviews are documented
     and stored in the compliance evidence repository.

  k. Service accounts (shared by nature) have credentials rotated when team
     membership changes. Credentials are stored in AWS Secrets Manager with
     automatic rotation enabled.

Control Enhancements Implemented:
  - AC-2(1): Automated provisioning/deprovisioning via Okta + Lambda
  - AC-2(2): Automatic disable of emergency accounts after 72 hours
  - AC-2(3): Automated disable of inactive accounts after 90 days
  - AC-2(4): CloudTrail logging of all account management actions
  - AC-2(9): Prohibition of shared user accounts (policy enforced)

Evidence:
  - Access Control Policy v1.8 (approved 2024-01-15)
  - Okta to AWS SSO integration documentation
  - Lambda function: sync-okta-to-sso (source code + logs)
  - Quarterly access review reports (2024-Q1 through Q4)
  - CloudTrail logs (full year, 365-day retention)
  - Jira access request tickets (sample 25)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
TESTING AND VALIDATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Control Effectiveness Testing:

✓ Design Testing (Point-in-Time):
  - Review Access Control Policy for completeness
  - Verify automated provisioning workflow exists
  - Validate approval matrix (manager, CISO, security)
  - Confirm CloudTrail logging enabled

✓ Operating Effectiveness Testing (Period):
  - Sample 25 access requests: verify approval before access
  - Sample 25 terminations: verify timely deprovisioning (<4 hours)
  - Sample 4 quarterly reviews: verify completeness and sign-off
  - Review CloudTrail logs for unauthorized account changes
  - Test emergency account auto-disable (create test account)
  - Test inactive account detection (check credential report)

Test Commands:
```bash
# Test automated provisioning
/grc-engineer:test-control AC-2

# Validate CloudTrail logging
aws cloudtrail lookup-events --lookup-attributes AttributeKey=EventName,AttributeValue=CreateUser

# Check inactive accounts
aws iam generate-credential-report
aws iam get-credential-report

# Verify access reviews exist
ls -l ./evidence/access-reviews/2024-Q*

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ COMPENSATING CONTROLS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

If Unable to Implement Enhancement:

Cannot implement AC-2(1) - Automated Account Management: Compensating Control: - Daily manual review of pending access requests - HR sends termination list to IT daily (not real-time) - Weekly manual review of all active accounts Risk Acceptance: - Higher risk of delayed deprovisioning - Increased manual effort and potential errors Approval Required: CISO + Risk Committee

Cannot implement AC-2(3) - Disable Inactive Accounts: Compensating Control: - Monthly manual review of IAM credential report - Manager attestation for inactive accounts (justification) - Quarterly verification that attested accounts still need access Risk Acceptance: - Inactive accounts remain enabled longer - Increased attack surface Approval Required: CISO

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ RECOMMENDATIONS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Immediate Actions:

  1. Implement AC-2(1), AC-2(2), AC-2(3), AC-2(4) (core enhancements)
  2. Generate IaC for implementation: /soc2:gap-to-code gaps.json aws
  3. Document tailoring decisions in SSP
  4. Update Access Control Policy with tailored parameters

Within 3 Months:

  1. Consider AC-2(9) if shared accounts still exist
  2. Evaluate AC-2(12) for enhanced monitoring
  3. Review if AC-2(7) needed (separate privileged accounts)

Continuous:

  1. Test control effectiveness: /grc-engineer:test-control AC-2
  2. Review tailoring decisions annually
  3. Update as cloud environment evolves

## YAML Export

```yaml
control: AC-2
baseline: moderate
environment: cloud
tailoring_date: 2025-01-28
organization: Your Company

enhancements_selected:
  - id: AC-2(1)
    name: Automated System Account Management
    selected: true
    justification: "Reduces manual errors, required for timely terminations"
    implementation: "Okta webhook + AWS Lambda + SSO"

  - id: AC-2(2)
    name: Removal of Temporary / Emergency Accounts
    selected: true
    justification: "Prevents forgotten emergency accounts"
    implementation: "EventBridge + Lambda (72-hour expiry)"

  - id: AC-2(3)
    name: Disable Inactive Accounts
    selected: true
    justification: "PCI-DSS requirement (90 days)"
    implementation: "Daily Lambda checks IAM credential report"

  - id: AC-2(4)
    name: Automated Audit Actions
    selected: true
    justification: "Audit trail required for compliance"
    implementation: "CloudTrail + CloudWatch Logs (365 days)"

  - id: AC-2(9)
    name: Restrictions on Use of Shared Groups / Accounts
    selected: true
    justification: "Best practice, improves accountability"
    implementation: "Policy + AWS Config rule check"

parameters:
  account_types:
    - Workforce (federated via Okta)
    - Service accounts (IAM roles)
    - Emergency access (break-glass, 72h max)
    - Contractors (max 6 months)

  approval_roles:
    standard: "Direct manager"
    privileged: "Manager + CISO"
    service: "App owner + Security"
    emergency: "CISO only"

  review_frequency:
    standard: "Quarterly (90 days)"
    privileged: "Monthly (30 days)"
    automated: "Daily (inactive check)"

  procedures:
    provisioning: "Automated via Okta webhook"
    deprovisioning: "Automated within 4 hours"
    modification: "Jira approval + automated update"

Related Commands

  • /nist:select-baseline - Select appropriate NIST baseline
  • /nist:overlay-apply - Apply FedRAMP, DoD, or privacy overlays
  • /nist:ssp-section-generate - Generate SSP text from tailoring
  • /grc-engineer:generate-implementation - Generate IaC for controls
  • /grc-engineer:test-control - Test control effectiveness
  • /soc2:gap-to-code - Generate cloud infrastructure for gaps

NIST 800-53 Evidence Checklist

Generates audit-ready evidence collection checklists for NIST SP 800-53 Rev 5 controls and control families, scoped to a NIST SP 800-53B baseline (Low / Moderate / High). Evidence depth tracks the baseline: higher baselines pull in additional control enhancements and tighter organization-defined parameters, so the checklist grows accordingly.

NIST 800-53 is a control catalog, not a regulation. Enforcement comes from the authorizing program that profiles it — FISMA for federal systems, the FedRAMP PMO for cloud services, StateRAMP for state/local, CMMC/NIST 800-171 for the defense industrial base. This command produces the evidence an assessor asks for under any of those programs, organized by the framework's own control families and aligned to the NIST SP 800-53A assessment methods (examine / interview / test).

Never commit evidence artifacts to source control. The outputs below include real usernames, credential reports, MFA device states, and privileged-account inventories. .gitignore covers evidence/ by default so git add -A will not sweep it up, but durable storage is your responsibility. Use an encrypted, access-controlled evidence locker (encrypted S3 with least-privilege IAM, a GRC platform, or a shared drive with full-disk encryption and MFA-gated access).

Usage

/nist-800-53:evidence-checklist <control-id|family> [--baseline <low|moderate|high>] [--export <markdown|json|csv>]

Arguments

  • <control-id|family>: A single control (e.g., AC-2, AU-3, SC-13) or a whole control family (e.g., AC, AU, SC). A family expands to every control in that family that is in scope for the selected baseline.
  • --baseline: NIST SP 800-53B baseline — low, moderate, or high. Default: moderate. Drives which control enhancements and organization-defined parameters appear, and therefore how much evidence the checklist asks for.
  • --export: Output format — markdown, json, or csv. Default: markdown. JSON and CSV emit one row per evidence item for ingestion into a GRC platform or evidence tracker.

How baseline scoping works

Use the actual allocations for each control in the selected baseline, including enhancements at Low. Do not infer allocation from the impact level alone. Check the official NIST OSCAL baseline profiles, and reconcile the selected and tailored profile with the SSP and authorizing program.

  • low — allocated base controls and enhancements (for example, IA-2(1)).
  • moderate — controls and enhancements allocated to Moderate.
  • high — controls and enhancements allocated to High.

Organization-defined parameters (ODPs) depend on the applicable profile and organizational decisions; they do not universally tighten with baseline. Reconcile any example values against your SSP and authorization boundary.

Baseline allocations follow NIST SP 800-53B. Control intent is paraphrased and referenced by control ID; consult the official NIST catalog for normative text.

Example 1 — AC-2 Account Management (Moderate baseline)

/nist-800-53:evidence-checklist AC-2 --baseline moderate

Output:

NIST 800-53 Evidence Checklist
Control: AC-2 — Account Management
Family: AC (Access Control)
Baseline: Moderate (per NIST SP 800-53B)
Enhancements in scope (Moderate): AC-2(1), AC-2(2), AC-2(3), AC-2(4), AC-2(5), AC-2(13)
Assessment methods (per SP 800-53A): Examine, Interview, Test

## Control Intent (paraphrased)

Establish, document, and manage system accounts across their full lifecycle:
define account types and assign account managers, require approval before
creation, provision and de-provision per documented conditions, and review
accounts at an organization-defined frequency. At Moderate, much of this is
expected to be automated and audited.

## Evidence Requirements

### Required Documentation

□ **SSP — AC-2 implementation statement**
  - Implementation narrative for AC-2 and each Moderate enhancement in scope
  - Account types defined (user, privileged, service, temporary, emergency)
  - Account manager roles and approval authority
  - Evidence: SSP AC-2 section (and enhancement sub-sections)
  - Frequency: Annual review, or when implementation changes

□ **Account Management Policy and Procedures (ties to AC-1)**
  - Approval workflow, conditions for role/group membership, review cadence
  - Least-privilege and separation-of-duties references (AC-5 / AC-6)
  - Evidence: Signed policy + procedure, reviewed at the org-defined frequency
  - Frequency: At least annually

□ **Access authorization records**
  - Account request → approval → provisioning records (AC-2a–c)
  - Evidence: Sample of approved account requests from the assessment period
  - Frequency: Ongoing; sampled at assessment

### Automated Evidence Collection

✓ **Account inventory and credential state** — AC-2(1) automated management

```bash
(
set -e -o pipefail
umask 077
mkdir -p evidence && chmod 700 evidence || exit 1
stamp=$(date +%Y%m%d)
staging=$(mktemp -d "evidence/.nist-collector.XXXXXXXX")
trap 'rm -rf -- "$staging"' EXIT
# IAM principals (users, roles, groups)
aws iam list-users  --output json > "$staging/nist-ac2-iam-users-${stamp}.json"
aws iam list-roles  --output json > "$staging/nist-ac2-iam-roles-${stamp}.json"
aws iam list-groups --output json > "$staging/nist-ac2-iam-groups-${stamp}.json"

# Credential report: password age, MFA, access-key age/last-use.
# generate-credential-report is asynchronous — it returns STARTED/INPROGRESS and
# builds in the background, so poll for COMPLETE before fetching. Reading too
# early errors out and leaves you with no artifact.
#
# Bound the loop and check the AWS call's own exit status. Piping straight into
# grep hides a failure: a denied iam:GenerateCredentialReport makes grep return
# non-zero every pass, so an unbounded `until` turns a permissions error into a
# silent hang instead of an error you can act on.
state=""
for _ in $(seq 1 12); do
  if ! state=$(aws iam generate-credential-report --query State --output text); then
    echo "ERROR: generate-credential-report failed — check iam:GenerateCredentialReport." >&2
    exit 1
  fi
  [ "$state" = "COMPLETE" ] && break
  sleep 5
done
if [ "$state" != "COMPLETE" ]; then
  echo "ERROR: credential report still '$state' after 60s — rerun once it finishes." >&2
  exit 1
fi
aws iam get-credential-report --query Content --output text | base64 -d \
  > "$staging/nist-ac2-credential-report-${stamp}.csv"
# Publish only after every collection succeeds; each rename is atomic.
for artifact in "$staging"/*; do
  mv -f -- "$artifact" "evidence/${artifact##*/}"
done
)
```

✓ **Account lifecycle audit trail** — AC-2(4) automated audit actions

```bash
(
set -e -o pipefail
umask 077
mkdir -p evidence && chmod 700 evidence || exit 1
stamp=$(date +%Y%m%d)
staging=$(mktemp -d "evidence/.nist-collector.XXXXXXXX")
trap 'rm -rf -- "$staging"' EXIT
# Account create/modify/delete events from CloudTrail (last 30 days)
for ev in CreateUser DeleteUser AttachUserPolicy DetachUserPolicy; do
  aws cloudtrail lookup-events \
    --lookup-attributes AttributeKey=EventName,AttributeValue="$ev" \
    --start-time "$(date -u -d '30 days ago' +%Y-%m-%dT%H:%M:%S)" \
    --output json > "$staging/nist-ac2-lifecycle-$ev-${stamp}.json"
done
# Publish only after every collection succeeds; each rename is atomic.
for artifact in "$staging"/*; do
  mv -f -- "$artifact" "evidence/${artifact##*/}"
done
)
```

□ **Privileged account candidates (partial)** — direct user attachments of the named AWS managed policy only, not a complete inventory or proof of effective access. Review groups, inline and custom policies, roles, identity federation, permission boundaries, SCPs and resource policies separately; reconcile with the complete account population. AC-6(5) covers privileged-account review at Moderate+.

```bash
(
set -e -o pipefail
umask 077
mkdir -p evidence && chmod 700 evidence || exit 1
stamp=$(date +%Y%m%d)
staging=$(mktemp -d "evidence/.nist-collector.XXXXXXXX")
trap 'rm -rf -- "$staging"' EXIT
file="$staging/nist-ac2-privileged-$stamp.csv"
: > "$file"
# Principals carrying AdministratorAccess (adjust for your privileged policy set)
users=$(aws iam list-users --query 'Users[].UserName' --output text) || exit 1
for u in $users; do
  policies=$(aws iam list-attached-user-policies --user-name "$u" \
    --query 'AttachedPolicies[?PolicyName==`AdministratorAccess`].PolicyName' \
    --output text) || exit 1
  if [ "$policies" = AdministratorAccess ]; then
    echo "$u,AdministratorAccess" >> "$file" || exit 1
  fi
done
# Publish only after every collection succeeds; each rename is atomic.
for artifact in "$staging"/*; do
  mv -f -- "$artifact" "evidence/${artifact##*/}"
done
)
```

✓ **Inactive account detection** — AC-2(3) disable accounts (confirm the inactivity ODP, e.g., 90 days)

```bash
(
set -e -o pipefail
umask 077
mkdir -p evidence && chmod 700 evidence || exit 1
stamp=$(date +%Y%m%d)
staging=$(mktemp -d "evidence/.nist-collector.XXXXXXXX")
trap 'rm -rf -- "$staging"' EXIT
# Password-enabled accounts unused beyond the org-defined inactivity window
aws iam get-credential-report --query Content --output text | base64 -d \
  > "$staging/nist-ac2-inactive-review-${stamp}.csv"
# Review password_last_used against your ODP; flag and disable stale accounts.
# This file carries usernames, MFA state, and key ages — treat it as evidence,
# not scratch: keep it in the encrypted locker, never in /tmp or a shared path.
# Publish only after every collection succeeds; each rename is atomic.
for artifact in "$staging"/*; do
  mv -f -- "$artifact" "evidence/${artifact##*/}"
done
)
```

Collection frequency: monthly inventory, weekly for privileged and inactive checks.
Retention: per the authorizing program (commonly multi-year for federal systems).
Purpose: demonstrate automated, audited account management at Moderate.

### Manual Evidence Collection

□ **Inactivity logout — AC-2(5)**
  - Document the organization-defined inactivity period and configure automatic session logout for applicable systems; reconcile scope and exceptions with the SSP.
  - Evidence: session timeout configuration and a dated test showing an inactive session is automatically logged out within the defined period.

□ **Periodic account review records (AC-2 review requirement)**
  - Account list reviewed at the org-defined frequency, with manager certification
  - Inappropriate access identified and remediated within the defined window
  - Approving official sign-off
  - Evidence: Completed account review packages for the period
  - Frequency: Org-defined (commonly quarterly for Moderate)

□ **Temporary / emergency account handling — AC-2(2)**
  - Evidence that temporary and emergency accounts auto-expire or are removed
  - Evidence: Account TTL configuration + a sample of expired temp/emergency accounts

□ **Shared / group account credential management — base AC-2**
  - Process to change shared/group authenticators when a member leaves the group (a base AC-2 requirement), plus justification and approval for any shared accounts
  - Evidence: The credential-change procedure and shared-account approval records

□ **Disable accounts of high-risk individuals — AC-2(13)**
  - Coordinate with incident-response / insider-threat processes to disable a flagged individual's accounts within the org-defined window (this enhancement enters at Moderate, not High)
  - Evidence: Disablement records tied to a documented risk determination

## Baseline Depth — AC-2 across Low / Moderate / High

- **Low** — Base AC-2 only. Inventory, policy/procedures, account approvals, and a manual periodic review. No enhancement evidence required.
- **Moderate** — Adds AC-2(1)(2)(3)(4)(5)(13): automated account management, automated temporary/emergency account handling, automated disabling of inactive accounts, automated audit actions, inactivity logout, and disabling accounts of high-risk individuals.
- **High** — Adds AC-2(11)(12): enforced usage conditions and account monitoring for atypical usage (behavioral analytics / alerting). AC-2(13) already enters at Moderate.

## Assessment Methods (per SP 800-53A)

- **Examine** — account management policy/procedures, the SSP AC-2 section, account lists, and completed review records.
- **Interview** — account managers, system/network administrators, and the ISSO.
- **Test** — the automated mechanisms for provisioning, disabling, and audit-action generation (for example, trigger a deprovision and confirm the audit event and access removal).

Example 2 — AU-6 Audit Record Review, Analysis, and Reporting (High baseline)

/nist-800-53:evidence-checklist AU-6 --baseline high

Output:

NIST 800-53 Evidence Checklist
Control: AU-6 — Audit Record Review, Analysis, and Reporting
Family: AU (Audit and Accountability)
Baseline: High (per NIST SP 800-53B)
Enhancements in scope (High): AU-6(1), AU-6(3), AU-6(5), AU-6(6)
Assessment methods (per SP 800-53A): Examine, Interview, Test

## Control Intent (paraphrased)

Review and analyze system audit records at an organization-defined frequency
for indications of inappropriate or unusual activity, report findings to
defined roles, and adjust the level of review based on risk and threat
information. At High, review is automated, correlated across repositories, and
integrated with non-audit data sources including physical access monitoring.

## Evidence Requirements

### Required Documentation

□ **SSP — AU-6 implementation statement**
  - Narrative for AU-6 and each High enhancement in scope
  - Defined review frequency, responsible roles, and escalation paths
  - Working definition of "inappropriate or unusual activity"
  - Evidence: SSP AU-6 section (and enhancement sub-sections)
  - Frequency: Annual review, or when implementation changes

□ **Audit review, analysis, and reporting procedures (ties to AU-1)**
  - Who reviews, how often, what triggers escalation, and to whom findings go
  - Evidence: Signed procedure document
  - Frequency: At least annually

### Automated Evidence Collection

✓ **Automated review integration** — AU-6(1) integrate with a SIEM/analysis capability

```bash
(
set -e -o pipefail
umask 077
mkdir -p evidence && chmod 700 evidence || exit 1
stamp=$(date +%Y%m%d)
staging=$(mktemp -d "evidence/.nist-collector.XXXXXXXX")
trap 'rm -rf -- "$staging"' EXIT
# Proof that audit records flow into a centralized analysis pipeline
aws logs describe-subscription-filters \
  --log-group-name "<your-audit-log-group>" \
  --output json > "$staging/nist-au6-siem-subscriptions-${stamp}.json"
# Publish only after every collection succeeds; each rename is atomic.
for artifact in "$staging"/*; do
  mv -f -- "$artifact" "evidence/${artifact##*/}"
done
)
```

✓ **Cross-repository correlation** — AU-6(3) correlate audit record repositories

```bash
(
set -e -o pipefail
umask 077
mkdir -p evidence && chmod 700 evidence || exit 1
stamp=$(date +%Y%m%d)
staging=$(mktemp -d "evidence/.nist-collector.XXXXXXXX")
trap 'rm -rf -- "$staging"' EXIT
# Evidence that multiple audit sources are aggregated for correlation
aws securityhub get-enabled-standards \
  --output json > "$staging/nist-au6-securityhub-standards-${stamp}.json"
aws guardduty list-detectors \
  --output json > "$staging/nist-au6-guardduty-detectors-${stamp}.json"
# Publish only after every collection succeeds; each rename is atomic.
for artifact in "$staging"/*; do
  mv -f -- "$artifact" "evidence/${artifact##*/}"
done
)
```

✓ **Integrated analysis across data sources** — AU-6(5) combine audit with scan/performance data

```bash
(
set -e -o pipefail
umask 077
mkdir -p evidence && chmod 700 evidence || exit 1
stamp=$(date +%Y%m%d)
staging=$(mktemp -d "evidence/.nist-collector.XXXXXXXX")
trap 'rm -rf -- "$staging"' EXIT
# Aggregated findings that fuse audit data with vulnerability and config signals.
# No --max-items here on purpose: the CLI auto-paginates, and a capped artifact
# would silently stop mid-population while still looking complete to a reader.
aws securityhub get-findings \
  --filters '{"RecordState":[{"Value":"ACTIVE","Comparison":"EQUALS"}]}' \
  --output json > "$staging/nist-au6-integrated-findings-${stamp}.json"
# Publish only after every collection succeeds; each rename is atomic.
for artifact in "$staging"/*; do
  mv -f -- "$artifact" "evidence/${artifact##*/}"
done
)
```

If the finding volume makes a full pull impractical, narrow the population with
an explicit, defensible filter (an assessment-period date range, a severity
floor, a specific product ARN) and record that filter alongside the artifact. A
scope you can state and justify is evidence; an arbitrary row cap is a truncated
population an assessor will treat as incomplete.

Collection frequency: continuous ingestion; review at the org-defined cadence.
Retention: per the authorizing program's audit-retention parameter (see AU-11).
Purpose: demonstrate automated, correlated, integrated review at High.

### Manual Evidence Collection

□ **Audit review records and findings reports**
  - Dated review sign-offs at the org-defined frequency
  - Findings escalated to the ISSO / authorizing official with disposition
  - Evidence: Review minutes + findings reports for the period

□ **Physical/logical correlation — AU-6(6)**
  - Evidence that logical audit findings are correlated with physical access
    monitoring (PACS / badge logs) during investigations
  - Evidence: A worked example correlating a system event with physical entry data

□ **Review-level adjustment**
  - Evidence that review scope/frequency was adjusted in response to threat
    intelligence or law-enforcement information
  - Evidence: Tuning records tied to a threat trigger

## Baseline Depth — AU-6 across Low / Moderate / High

- **Low** — Base AU-6. Manual or periodic review of audit records, documented findings, and reporting to defined roles. No enhancement evidence required.
- **Moderate** — Adds AU-6(1) automated review integration (SIEM/monitoring tooling) and AU-6(3) correlation across audit repositories for situational awareness.
- **High** — Adds AU-6(5) integrated analysis that fuses audit records with vulnerability/performance/other data, and AU-6(6) correlation with physical access monitoring.

## Assessment Methods (per SP 800-53A)

- **Examine** — audit review/analysis/reporting policy, the SSP AU-6 section, review records, and findings reports.
- **Interview** — audit reviewers, SOC analysts, and the ISSO.
- **Test** — the automated review, correlation, and analysis mechanisms (for example, inject a benign anomalous event and confirm it surfaces, correlates, and alerts).

Family-level usage

Passing a family instead of a single control expands the checklist to every control in that family that is in scope for the selected baseline:

/nist-800-53:evidence-checklist AU --baseline high

This produces a checklist covering AU-2, AU-3, AU-6, AU-11, AU-12, and the other AU controls allocated to High, each with its own documentation / automated / manual evidence breakdown. Use a single control ID when you want depth; use a family when you want coverage.

Export formats

The default markdown output is the human-readable checklist above. json and csv flatten the same content to one row per evidence item for ingestion into a GRC platform or evidence tracker.

[
  {
    "control_id": "AC-2",
    "enhancement": "AC-2(3)",
    "family": "AC",
    "baseline": "moderate",
    "evidence_type": "automated",
    "artifact": "Inactive-account report from IAM credential report",
    "method": "test",
    "frequency": "weekly",
    "odp_note": "Confirm inactivity window against SSP (FedRAMP commonly 90 days)"
  }
]

CSV emits the same fields as a header row plus one line per item:

control_id,enhancement,family,baseline,evidence_type,artifact,method,frequency,odp_note
AC-2,AC-2(3),AC,moderate,automated,Inactive-account report from IAM credential report,test,weekly,Confirm inactivity window against SSP

Cross-References

Related controls

  • AC-2 ties to AC-1 (policy), AC-3 (enforcement), AC-5 (separation of duties), AC-6 (least privilege), AU-2 (auditable events), and IA-2 / IA-4 / IA-5 (identification and authenticator management).
  • AU-6 ties to AU-2 (event selection), AU-3 (record content), AU-7 (reduction/reporting), AU-11 (retention), AU-12 (generation), IR-4 / IR-5 (incident handling and monitoring), and SI-4 (system monitoring).

Maps to other frameworks

These are representative crosswalks; confirm exact mappings with /grc-engineer:map-controls-unified (the SCF crosswalk is the canonical source).

AC-2 (Account Management):

  • FedRAMP: AC-2 (same control, profiled)
  • SOC 2: CC6.1, CC6.2, CC6.3
  • ISO 27001:2022: A.5.15, A.5.16, A.5.18
  • CMMC L2 / NIST 800-171: 3.1.1, 3.1.2

AU-6 (Audit Record Review, Analysis, and Reporting):

  • FedRAMP: AU-6 (same control, profiled)
  • SOC 2: CC7.2, CC7.3
  • ISO 27001:2022: A.8.15, A.8.16
  • CMMC L2 / NIST 800-171: 3.3.3, 3.3.5

Evidence Package Structure

evidence/
└── nist-800-53/
    ├── ac-2-account-management/
    │   ├── ssp/ssp-ac2-vX.docx
    │   ├── policy/account-management-policy-signed.pdf
    │   ├── automated/
    │   │   ├── 2026-01/iam-users-20260131.json
    │   │   ├── 2026-01/credential-report-20260131.csv
    │   │   ├── 2026-01/lifecycle-202601.json
    │   │   └── 2026-01/privileged-20260131.csv
    │   └── reviews/Q1-2026-account-review-signed.pdf
    ├── au-6-audit-review/
    │   ├── ssp/ssp-au6-vX.docx
    │   ├── procedures/audit-review-procedure.pdf
    │   ├── automated/
    │   │   ├── siem-subscriptions-20260131.json
    │   │   └── integrated-findings-20260131.json
    │   └── reviews/2026-01-audit-review-minutes.pdf
    └── README.md  (evidence index + retention schedule)

Automation Script

A baseline-aware AC-2 collector. The baseline argument gates which checks run, so a Low-baseline run does not produce enhancement evidence it does not need.

#!/usr/bin/env python3
"""NIST 800-53 AC-2 Account Management evidence collection (baseline-aware)."""
import argparse
import csv
import io
import json
import os
import time
from datetime import datetime, timezone

import boto3

# Which AC-2 enhancements each baseline pulls in (per NIST SP 800-53B).
BASELINE_ENHANCEMENTS = {
    "low": [],
    "moderate": ["AC-2(1)", "AC-2(2)", "AC-2(3)", "AC-2(4)", "AC-2(5)", "AC-2(13)"],
    "high": ["AC-2(1)", "AC-2(2)", "AC-2(3)", "AC-2(4)", "AC-2(5)",
             "AC-2(11)", "AC-2(12)", "AC-2(13)"],
}

# Managed policies treated as admin-equivalent. Extend with your own
# customer-managed admin policy names — this list is a starting point, not a
# complete definition of "privileged" for your environment.
ADMIN_POLICIES = {"AdministratorAccess", "PowerUserAccess", "IAMFullAccess"}


class AC2Evidence:
    """Collects AC-2 account-management evidence scoped to a baseline."""

    def __init__(self, baseline, inactivity_days, out_dir="evidence/nist-800-53/ac-2-account-management"):
        self.baseline = baseline
        self.enhancements = BASELINE_ENHANCEMENTS[baseline]
        self.inactivity_days = inactivity_days
        self.stamp = datetime.now(timezone.utc).strftime("%Y%m%d")
        self.out_dir = os.path.join(out_dir, "automated", datetime.now(timezone.utc).strftime("%Y-%m"))
        # 0700/0600: this directory fills with usernames, MFA state, and key ages.
        # makedirs' mode only applies when it creates the directory, so chmod the
        # existing case too — a rerun into an already-loose directory is the
        # common path, not the rare one.
        os.makedirs(self.out_dir, mode=0o700, exist_ok=True)
        os.chmod(self.out_dir, 0o700)
        self.iam = boto3.client("iam")

    def _write(self, name, payload):
        path = os.path.join(self.out_dir, f"{name}-{self.stamp}.json")
        with self._open_private(path) as fh:
            json.dump(payload, fh, indent=2, default=str)
        return path

    def _open_private(self, path):
        """Open a file for writing that is 0600 from the moment it exists.

        The builtin open() has no mode parameter, so it creates at the umask
        default and needs a follow-up chmod. That chmod does not run if the
        write raises — leaving a half-written credential report readable by
        every account on the host until somebody notices. os.open maps onto the
        open(2) syscall, which does take a mode, so the file is never wrong even
        mid-write. It returns a file descriptor rather than a file object, and
        os.fdopen wraps that descriptor back into one.

        That mode only applies when os.open creates the file. Reruns land on the
        same dated filename, so an artifact left at looser permissions by an
        earlier run would keep them through O_TRUNC. fchmod on the open
        descriptor normalizes that case before anything is written.
        """
        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
        os.fchmod(fd, 0o600)
        return os.fdopen(fd, "w", encoding="utf-8")

    def _write_csv(self, name, content):
        """Persist a raw CSV artifact (the credential report) beside the JSON.

        The parsed rows are derived evidence; the report AWS handed back is the
        primary artifact an assessor asks for. Writing only the derived file
        leaves the evidence package missing the source it was built from.
        """
        path = os.path.join(self.out_dir, f"{name}-{self.stamp}.csv")
        with self._open_private(path) as fh:
            fh.write(content)
        return path

    def _paginate(self, operation, key, **kwargs):
        """Collect every page of a paginated IAM call into one list.

        The bare list_* calls cap at 100 items and set IsTruncated. A short list
        is not a cosmetic bug here: these lists are the AC-2 account population
        an assessor tests for completeness, so silently dropping user 101 makes
        the evidence wrong rather than merely partial.
        """
        items = []
        for page in self.iam.get_paginator(operation).paginate(**kwargs):
            items.extend(page[key])
        return items

    def _credential_report(self):
        """Return the IAM credential report as parsed CSV rows.

        botocore already base64-decodes the blob, so Content is raw CSV bytes
        (the AWS CLI path differs — there you must pipe through `base64 -d`).

        generate_credential_report is asynchronous: it returns State STARTED or
        INPROGRESS and builds the report in the background. Fetching immediately
        raises CredentialReportNotReady, which would abort the run after the
        inventory was already written — leaving a half-filled evidence directory
        that looks like a finished collection. So poll until COMPLETE.
        """
        state = self.iam.generate_credential_report()["State"]
        waited = 0
        while state != "COMPLETE" and waited < 60:
            time.sleep(5)
            waited += 5
            state = self.iam.generate_credential_report()["State"]
        if state != "COMPLETE":
            raise RuntimeError(
                f"IAM credential report still {state} after {waited}s — rerun once it finishes."
            )
        content = self.iam.get_credential_report()["Content"].decode("utf-8")
        self._write_csv("credential-report", content)
        return list(csv.DictReader(io.StringIO(content)))

    def account_inventory(self):
        """Base AC-2: enumerate principals. Always runs."""
        users = self._paginate("list_users", "Users")
        self._write("iam-users", users)
        print(f"[base] account inventory: {len(users)} users")
        return users

    def inactive_accounts(self, rows):
        """AC-2(3): flag accounts idle beyond the inactivity ODP. Moderate+ only.

        Two sentinels in the credential report mean opposite things to a naive
        filter. "no_information" on password_last_used means the password has
        never been used; "N/A" means the credential does not exist. Skipping
        "no_information" drops every never-signed-in account — the most stale
        population in the report — out of the AC-2(3) artifact.

        Console activity alone is also the wrong population. A user with no
        password but a two-year-old access key is an inactive account. So take
        the most recent activity across the password and both access keys, and
        treat an account with no activity at all as inactive rather than exempt.
        """
        if "AC-2(3)" not in self.enhancements:
            print("[skip] AC-2(3) not in scope for baseline 'low'")
            return []

        # "not_supported" shows up on root and on credential types an account
        # cannot use; like "N/A" it means no timestamp exists, not recent use.
        no_timestamp = ("N/A", "no_information", "not_supported", "")
        activity_fields = [
            "password_last_used",
            "access_key_1_last_used_date",
            "access_key_2_last_used_date",
        ]

        stale = []
        for row in rows:
            # Root has no lifecycle to review under AC-2(3), and an unused root
            # is the desired state — flagging it would invert the finding.
            if row.get("user") == "<root_account>":
                continue

            timestamps = []
            for field in activity_fields:
                value = row.get(field, "N/A")
                if value not in no_timestamp:
                    timestamps.append(datetime.fromisoformat(value.replace("Z", "+00:00")))

            if timestamps:
                last_active = max(timestamps)
                idle_days = (datetime.now(timezone.utc) - last_active).days
                last_seen = last_active.isoformat()
            else:
                # No usable timestamp on any credential: the account has never
                # been used. Age it from creation rather than flagging outright —
                # a user provisioned yesterday has not yet had time to be
                # inactive, and reporting it as over a 90-day threshold is a
                # false positive an assessor will use to discount the artifact.
                created = row.get("user_creation_time", "")
                if created:
                    created_at = datetime.fromisoformat(created.replace("Z", "+00:00"))
                    idle_days = (datetime.now(timezone.utc) - created_at).days
                    last_seen = "never used"
                else:
                    # Never used, and no creation date to age it against. Dropping
                    # the row would silently shrink the population, which is the
                    # failure this checklist exists to argue against — so report
                    # it for manual review instead of skipping it.
                    idle_days = None
                    last_seen = "never used (creation date unavailable)"

            if idle_days is None or idle_days > self.inactivity_days:
                stale.append({
                    "user": row["user"],
                    "last_activity": last_seen,
                    "idle_days": idle_days,
                    "user_creation_time": row.get("user_creation_time", ""),
                })
        self._write("inactive-accounts", stale)
        flag = "OK" if not stale else f"{len(stale)} OVER {self.inactivity_days}d — disable per AC-2(3)"
        print(f"[AC-2(3)] inactive accounts: {flag}")
        return stale

    def privileged_inventory(self, users):
        """Privileged-principal inventory across IAM users. Runs at every baseline.

        Base AC-2 requires privileged accounts to be identified as an account
        type, so this inventory is base evidence rather than an enhancement — it
        runs at Low too. Only the dedicated privileged-account *review* control,
        AC-6(5), is Moderate+, and that changes the label on the artifact, not
        whether it gets collected.

        Admin reaches a user three ways: a directly attached managed policy, a
        managed policy inherited from a group, or an inline policy. Checking only
        the first misses group-based admin — the pattern AWS actually recommends —
        and reports real administrators as unprivileged. An understated privileged
        population is the finding an assessor writes up, so check all three.

        This is a candidate list, not an effective-access determination. All
        managed policies and inline-policy names are retained for manual review.
        Roles, federation and other access paths must be reviewed separately.
        """
        privileged = []
        group_policies = {}
        for user in users:
            name = user["UserName"]
            matched = []
            managed_review = []
            group_inline = []

            for policy in self._paginate("list_attached_user_policies",
                                         "AttachedPolicies", UserName=name):
                if policy["PolicyName"] in ADMIN_POLICIES:
                    matched.append(policy["PolicyName"])
                managed_review.append(policy["PolicyArn"])

            for group in self._paginate("list_groups_for_user", "Groups", UserName=name):
                group_name = group["GroupName"]
                if group_name not in group_policies:
                    group_policies[group_name] = (
                        self._paginate("list_attached_group_policies", "AttachedPolicies", GroupName=group_name),
                        self._paginate("list_group_policies", "PolicyNames", GroupName=group_name),
                    )
                managed, inline_names = group_policies[group_name]
                for policy in managed:
                    if policy["PolicyName"] in ADMIN_POLICIES:
                        matched.append(f"{policy['PolicyName']} (via group {group_name})")
                    managed_review.append(f"{policy['PolicyArn']} (via group {group_name})")
                for policy_name in inline_names:
                    group_inline.append(f"{policy_name} (via group {group_name})")

            # Inline policy names are arbitrary, so they cannot be matched against
            # ADMIN_POLICIES. Surface them for manual review rather than guessing.
            inline = self._paginate("list_user_policies", "PolicyNames", UserName=name)

            # Keep every user, including users with no listed policies: omission
            # is not proof of no effective access (e.g. resource-based grants).
            privileged.append({
                    "user": name,
                    "admin_policies": sorted(set(matched)),
                    "managed_policies_for_manual_review": sorted(set(managed_review)),
                    "inline_policies_for_manual_review": inline,
                    "group_inline_policies_for_manual_review": sorted(set(group_inline)),
                })
        self._write("privileged-candidates-partial", {"complete": False, "scope": "IAM users only; manual effective-access review required, including roles and federation", "users": privileged})
        label = "base AC-2" if self.baseline == "low" else "AC-6(5)"
        print(f"[{label}] {len(privileged)} IAM users for manual review; "
              f"partial candidates only, not a complete privileged inventory")
        return privileged

    def run(self):
        print(f"AC-2 evidence collection — baseline={self.baseline}, "
              f"enhancements in scope: {self.enhancements or 'none (base control only)'}")
        users = self.account_inventory()
        # The credential report exists here to serve AC-2(3). Gate the call, not
        # just the consumer: at Low it is an API call the baseline puts out of
        # scope, and it would write a sensitive artifact the checklist then
        # declares irrelevant.
        if "AC-2(3)" in self.enhancements:
            self.inactive_accounts(self._credential_report())
        else:
            print("[skip] credential report not collected — AC-2(3) out of scope at 'low'")
        self.privileged_inventory(users)
        print(f"Evidence written to {self.out_dir}/  —  do not commit this directory.")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Collect NIST 800-53 AC-2 evidence.")
    parser.add_argument("--baseline", choices=["low", "moderate", "high"], default="moderate")
    parser.add_argument("--inactivity-days", type=int, default=90,
                        help="Inactivity ODP; reconcile to your SSP (FedRAMP commonly 90).")
    args = parser.parse_args()
    AC2Evidence(args.baseline, args.inactivity_days).run()

Catalog: NIST SP 800-53 Rev 5 Baselines: NIST SP 800-53B (Low / Moderate / High) Assessment procedures: NIST SP 800-53A Rev 5 (examine / interview / test) Profiled by: FedRAMP, StateRAMP, CMMC / NIST 800-171, agency FISMA programs Evidence retention: per the authorizing program (see AU-11 for the audit-retention parameter)

NIST 800-53 Control Family Deep Dive

Provides comprehensive analysis of NIST 800-53 control families, including control overview, common implementations, cloud-specific guidance, and integration patterns for AWS/Azure/GCP.

Usage

/nist:family-deep-dive <family> [baseline] [options]

Arguments

  • $1 - Control family: "AC", "AU", "SC", "IA", "CM", "CP", "IR", "SI", "RA", etc.
  • $2 - Baseline (optional): "low", "moderate", "high" (default: "moderate")
  • $3 - Options (optional): --environment=cloud|hybrid|on-prem, --show-controls, --implementation-only

Examples

# Deep dive on Access Control family
/nist:family-deep-dive AC moderate

# Deep dive on Audit family for cloud
/nist:family-deep-dive AU moderate --environment=cloud

# Show all controls in family
/nist:family-deep-dive SC moderate --show-controls

# Implementation guidance only (skip theory)
/nist:family-deep-dive IA moderate --implementation-only

Output - Access Control (AC) Family

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
NIST 800-53 CONTROL FAMILY DEEP DIVE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Family: Access Control (AC)
Baseline: Moderate
Environment: Cloud (AWS, Azure, GCP)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FAMILY OVERVIEW
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Purpose:
  The Access Control family addresses the policies, procedures, and technical
  controls to limit information system access to authorized users, processes
  acting on behalf of authorized users, and devices (including other systems).

Core Principles:
  - Least Privilege: Users have minimum access needed
  - Separation of Duties: Critical functions split among multiple users
  - Need-to-Know: Access based on job function requirements
  - Defense in Depth: Multiple layers of access control

Control Count in Moderate Baseline: 25 controls
  - Base controls: 22
  - Enhancements: 3 additional
  - Optional enhancements: 40+ available

Maturity Model:
  Level 1 (Basic): Authentication, authorization, auditing
  Level 2 (Intermediate): RBAC, periodic reviews, automated provisioning
  Level 3 (Advanced): Attribute-based access, real-time analytics, zero trust

Common Failures:
  - Orphaned accounts (users who left but access remains)
  - Excessive privileges (admin access for non-admin tasks)
  - Stale access (permissions granted but no longer needed)
  - Shared accounts (cannot attribute actions to individuals)
  - No access reviews (permissions drift over time)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
KEY CONTROLS (Moderate Baseline)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

AC-1: Policy and Procedures
  Purpose: Establish governance for access control
  Implementation: Document access control policy, procedures, review annually
  Cloud Pattern: Store in version control (Git), require exec approval
  Effort: 16 hours (initial), 4 hours/year (review)
  Evidence: Policy document, approval memo, annual review log

AC-2: Account Management ⭐ HIGH PRIORITY
  Purpose: Manage system account lifecycle (create, modify, disable, delete)
  Implementation: Automated provisioning via identity provider
  Cloud Pattern: Okta/Azure AD → AWS SSO, automated deprovisioning
  Effort: 40 hours (automation setup), 10 hours/month (reviews)
  Evidence: IAM user lists, quarterly access reviews, termination logs
  Common Gap: Manual deprovisioning leads to orphaned accounts
  Fix: Integrate HR system with IAM for automated lifecycle

AC-3: Access Enforcement
  Purpose: Enforce approved authorizations for system access
  Implementation: RBAC or ABAC policies, deny-by-default
  Cloud Pattern: IAM policies, Security Groups, RBAC
  Effort: 24 hours (initial policy design)
  Evidence: IAM policy documents, access logs showing enforcement
  Common Gap: Overly permissive policies (e.g., AdministratorAccess for all)
  Fix: Implement least privilege via managed policies per role

AC-4: Information Flow Enforcement
  Purpose: Control information flow between systems and networks
  Implementation: Network segmentation, data loss prevention
  Cloud Pattern: VPCs, subnets, NACLs, Security Groups, VPC endpoints
  Effort: 32 hours (network design)
  Evidence: Network diagram, security group rules, flow logs
  Common Gap: Flat network (all systems can communicate)
  Fix: Segment by environment (dev/stage/prod) and tier (web/app/data)

AC-5: Separation of Duties
  Purpose: Divide critical functions among different individuals
  Implementation: Dual approval for sensitive actions, role segregation
  Cloud Pattern: IAM policies prevent single user from both create + approve
  Effort: 16 hours (policy design)
  Evidence: IAM policies showing separation, audit logs
  Example: Developers can create resources, but can't deploy to production

AC-6: Least Privilege ⭐ HIGH PRIORITY
  Purpose: Grant only minimum necessary permissions
  Implementation: Role-based policies, periodic permission reviews
  Cloud Pattern: Managed policies (AWS), Azure RBAC, GCP IAM
  Effort: 40 hours (initial), ongoing refinement
  Evidence: Permission analysis, unused permission reports
  Common Gap: Over-permissioning (easier to give broad access)
  Fix: Start with read-only, add permissions as needed with justification

AC-7: Unsuccessful Login Attempts
  Purpose: Lock accounts after failed login attempts
  Implementation: Failed login threshold (e.g., 5 attempts), lockout duration
  Cloud Pattern: Okta/Azure AD account lockout policy
  Effort: 2 hours (configuration)
  Evidence: Account lockout policy screenshot, lockout event logs
  Best Practice: 5 attempts, 30-minute lockout

AC-8: System Use Notification
  Purpose: Display warning banner before login
  Implementation: Login page banner, SSH banner
  Cloud Pattern: CloudFront → S3 static page with banner, SSH config
  Effort: 4 hours
  Evidence: Screenshot of banner, SSH config file
  Required Text: "Authorized use only. Activity monitored and logged."

AC-11: Session Lock
  Purpose: Lock session after period of inactivity
  Implementation: Auto-logout after inactivity
  Cloud Pattern: Okta/AWS SSO session timeout (15 minutes)
  Effort: 2 hours
  Evidence: Session policy configuration
  Best Practice: 15 minutes for general, 5 minutes for privileged

AC-14: Permitted Actions Without Identification
  Purpose: Identify actions allowed before authentication
  Implementation: Document unauthenticated endpoints (health checks, etc.)
  Cloud Pattern: ALB health check endpoint (no auth required)
  Effort: 4 hours (documentation)
  Evidence: List of public endpoints with justification

AC-17: Remote Access
  Purpose: Control remote access to systems
  Implementation: VPN, bastion hosts, MFA for remote access
  Cloud Pattern: AWS Session Manager, Azure Bastion, GCP IAP
  Effort: 24 hours
  Evidence: VPN config, bastion host logs, MFA enrollment
  Best Practice: No direct SSH, use Session Manager with MFA

AC-18: Wireless Access
  Purpose: Control wireless network access
  Implementation: WPA3 encryption, 802.1X authentication
  Cloud Pattern: N/A for cloud-only (office network if hybrid)
  Effort: 16 hours (if applicable)
  Evidence: Wireless config, authentication logs

AC-19: Access Control for Mobile Devices
  Purpose: Control mobile device access to systems
  Implementation: MDM, device enrollment, remote wipe
  Cloud Pattern: Okta Verify (mobile MFA), conditional access
  Effort: 20 hours
  Evidence: MDM enrollment list, mobile access logs
  Best Practice: Require MDM enrollment for corporate data access

AC-20: Use of External Information Systems
  Purpose: Control access via external systems
  Implementation: Approved vendor list, security requirements
  Cloud Pattern: VPN to partner networks, API authentication
  Effort: 12 hours (per external system)
  Evidence: Vendor agreements, security assessments
  Example: Allow Salesforce to access customer data via API (approved)

AC-22: Publicly Accessible Content
  Purpose: Control publicly posted information
  Implementation: Content approval process, review before publish
  Cloud Pattern: S3 bucket policies (deny public by default)
  Effort: 8 hours
  Evidence: S3 bucket policies, content approval workflow
  Common Gap: Accidentally public S3 buckets
  Fix: Enable S3 Block Public Access at account level

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CLOUD IMPLEMENTATION PATTERNS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

AWS Implementation:

Identity and Access Management:
  ✓ AWS IAM Identity Center (formerly AWS SSO)
    - Federate with Okta/Azure AD
    - Centralized access management
    - Multi-account support via Organizations

  ✓ IAM Policies
    - Managed policies for common roles
    - Inline policies for exceptions
    - Permission boundaries to limit max privileges

  ✓ IAM Roles (not users)
    - Service roles for applications (EC2, Lambda, ECS)
    - Cross-account roles for partner access
    - Temporary credentials (STS)

Account Management Automation:
  ✓ Okta → AWS SSO (SCIM provisioning)
  ✓ Lambda function: sync-users-to-sso
  ✓ Lambda function: deprovision-user-on-termination
  ✓ EventBridge: quarterly-access-review trigger

Network Access Control:
  ✓ VPC architecture (isolated networks)
  ✓ Security Groups (stateful firewall)
  ✓ Network ACLs (stateless firewall)
  ✓ AWS PrivateLink (private connectivity to services)
  ✓ VPC Endpoints (no internet routing for AWS services)

Remote Access:
  ✓ AWS Session Manager (no SSH keys, MFA enforced)
  ✓ AWS Systems Manager (port forwarding)
  ✓ Client VPN (if needed, with MFA)

Access Monitoring:
  ✓ CloudTrail (all API calls)
  ✓ GuardDuty (anomaly detection)
  ✓ Access Analyzer (detect overly broad permissions)
  ✓ CloudWatch (metrics and alarms)

Azure Implementation:

Identity and Access Management:
  ✓ Azure Active Directory (Entra ID)
    - Conditional access policies
    - Privileged Identity Management (PIM)
    - Identity Protection

  ✓ Azure RBAC
    - Built-in roles (Owner, Contributor, Reader)
    - Custom roles for specific permissions
    - Management group hierarchy

Account Management:
  ✓ Azure AD lifecycle workflows
  ✓ Automated provisioning/deprovisioning
  ✓ Guest user management (B2B)

Network Access Control:
  ✓ Virtual Networks (VNets)
  ✓ Network Security Groups (NSGs)
  ✓ Azure Firewall
  ✓ Private Link

Remote Access:
  ✓ Azure Bastion (browser-based RDP/SSH)
  ✓ Just-In-Time VM access
  ✓ Point-to-Site VPN

GCP Implementation:

Identity and Access Management:
  ✓ Cloud Identity
  ✓ Workforce Identity Federation
  ✓ IAM & Admin

  ✓ IAM Roles
    - Basic roles (Owner, Editor, Viewer)
    - Predefined roles (service-specific)
    - Custom roles

Account Management:
  ✓ Cloud Identity user lifecycle
  ✓ Google Workspace integration
  ✓ Automated provisioning via SCIM

Network Access Control:
  ✓ VPC networks
  ✓ Firewall rules
  ✓ Cloud NAT

Remote Access:
  ✓ Identity-Aware Proxy (IAP)
  ✓ OS Login (SSH key management)
  ✓ Cloud VPN

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
IMPLEMENTATION ROADMAP
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Phase 1: Foundation (Weeks 1-4)
  Priority: HIGH
  Controls: AC-1, AC-2, AC-3, AC-6

  Week 1:
    □ Document Access Control Policy (AC-1)
    □ Inventory all existing accounts
    □ Set up Okta tenant (or Azure AD)

  Week 2:
    □ Configure Okta → AWS SSO integration
    □ Migrate users to federated access
    □ Disable direct IAM users

  Week 3:
    □ Design RBAC matrix (roles and permissions)
    □ Create IAM policies for each role
    □ Test access enforcement (AC-3)

  Week 4:
    □ Implement least privilege policies (AC-6)
    □ Remove excessive permissions
    □ Test user workflows

  Effort: 160 hours
  Cost: $5,000 (Okta licenses)

Phase 2: Automation (Weeks 5-8)
  Priority: HIGH
  Controls: AC-2(1), AC-2(2), AC-2(3), AC-2(4)

  Week 5:
    □ Integrate BambooHR with Okta
    □ Set up SCIM provisioning
    □ Test automated account creation

  Week 6:
    □ Build Lambda: deprovision-user
    □ Integrate with BambooHR webhook
    □ Test automated deprovisioning

  Week 7:
    □ Build Lambda: check-inactive-accounts
    □ Set up daily EventBridge trigger
    □ Configure notifications

  Week 8:
    □ Configure CloudTrail for IAM events
    □ Set up GuardDuty
    □ Test anomaly detection

  Effort: 120 hours
  Cost: $2,000 (development)

Phase 3: Network Controls (Weeks 9-12)
  Priority: MEDIUM
  Controls: AC-4, AC-17, AC-20

  Week 9:
    □ Design VPC architecture (dev/stage/prod)
    □ Create security groups
    □ Configure NACLs

  Week 10:
    □ Implement VPC endpoints
    □ Remove internet gateways where possible
    □ Test connectivity

  Week 11:
    □ Set up AWS Session Manager
    □ Disable SSH key-based access
    □ Configure audit logging

  Week 12:
    □ Document external system connections
    □ Create VPN/PrivateLink for partners
    □ Test access controls

  Effort: 80 hours
  Cost: $500/month (VPN, Transit Gateway)

Phase 4: Review and Monitoring (Ongoing)
  Priority: MEDIUM
  Controls: AC-2(j), AC-6(9)

  Setup:
    □ Quarterly access review process
    □ Access review automation (reports)
    □ Dashboard for access metrics

  Ongoing:
    □ Quarterly access reviews (90 days)
    □ Monthly privileged access reviews
    □ Annual policy review

  Effort: 20 hours/quarter
  Cost: $0 (internal)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
TESTING AND VALIDATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Automated Testing:
```bash
# Test all AC family controls
/grc-engineer:test-control AC

# Test specific controls
/grc-engineer:test-control AC-2
/grc-engineer:test-control AC-6

Manual Testing Scenarios:

Test 1: Account Provisioning (AC-2)

  1. Create test user in BambooHR
  2. Verify Okta account created within 15 minutes
  3. Verify AWS SSO access granted
  4. Verify email notification sent to user Expected Result: Automated provisioning successful

Test 2: Account Termination (AC-2)

  1. Mark test user as terminated in BambooHR
  2. Verify Okta account disabled within 4 hours
  3. Verify AWS SSO access revoked
  4. Verify CloudTrail logs termination event Expected Result: Automated deprovisioning successful

Test 3: Access Enforcement (AC-3)

  1. Attempt to access resource without permission
  2. Verify access denied
  3. Verify denial logged in CloudTrail Expected Result: Access denied, audit trail created

Test 4: Least Privilege (AC-6)

  1. Review IAM policies for overly broad permissions
  2. Run Access Analyzer to detect unused permissions
  3. Verify no users have AdministratorAccess (except break-glass) Expected Result: All users follow least privilege

Test 5: Session Lock (AC-11)

  1. Log in to AWS console
  2. Wait 15 minutes without activity
  3. Attempt to perform action Expected Result: Session expired, re-authentication required

Test 6: Remote Access (AC-17)

  1. Attempt direct SSH to EC2 instance
  2. Verify SSH blocked (no public IPs, no key-based auth)
  3. Use Session Manager to connect
  4. Verify MFA required for Session Manager Expected Result: Session Manager works, direct SSH blocked

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ COMMON PITFALLS AND SOLUTIONS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Pitfall 1: Orphaned Accounts Problem: Users leave, accounts remain active Impact: Security risk, compliance violation Solution: Integrate HR system with IAM, automated deprovisioning Detection: Daily credential report, inactive account check Fix: /grc-engineer:generate-implementation AC-2 aws

Pitfall 2: Excessive Permissions Problem: Users have admin access when not needed Impact: Increased blast radius of compromise Solution: Implement least privilege, regular permission reviews Detection: AWS Access Analyzer, unused permission report Fix: Remove broad policies, create role-specific policies

Pitfall 3: No Access Reviews Problem: Permissions drift over time, never reviewed Impact: Users accumulate unnecessary access Solution: Automated quarterly access reviews Detection: Compare current access vs. required access Fix: EventBridge + Lambda to generate review reports

Pitfall 4: Shared Accounts Problem: Multiple users share one account Impact: Cannot attribute actions, accountability lost Solution: Unique accounts for all users, use roles for services Detection: Check for shared access keys (Access Analyzer) Fix: Disable shared accounts, create individual accounts

Pitfall 5: Weak Remote Access Problem: Direct SSH with password authentication Impact: Brute force attacks, credential theft Solution: Session Manager (no SSH keys), MFA required Detection: Review security group rules for port 22/3389 Fix: Disable public access, enable Session Manager

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ METRICS AND DASHBOARDS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Key Metrics to Track:

Access Management:

  • Total active accounts
  • Orphaned accounts detected (last 30 days)
  • Average deprovisioning time (target: <4 hours)
  • Access requests processed (monthly)
  • Access review completion rate (target: 100%)

Least Privilege:

  • Users with admin access (minimize)
  • Unused IAM permissions detected (Access Analyzer)
  • Overly permissive security groups (0.0.0.0/0)
  • Policies with wildcard actions (avoid)

Authentication:

  • MFA enrollment rate (target: 100%)
  • Failed login attempts (monthly trend)
  • Account lockouts (investigate spikes)
  • Password changes (compliance with policy)

Activity Monitoring:

  • Privileged access usage (admin console logins)
  • After-hours access (flag for review)
  • Unusual geographic access (GuardDuty findings)
  • API call volume anomalies

Dashboard Example (CloudWatch):

  • Widget 1: Active accounts (line chart, 30 days)
  • Widget 2: MFA enrollment % (gauge, target 100%)
  • Widget 3: Orphaned accounts (number, alert if >0)
  • Widget 4: Access review status (pie chart)
  • Widget 5: GuardDuty findings (bar chart by severity)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ COST ESTIMATE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Technology Costs (Annual): Okta (SSO + MFA): $3/user/month = $5,100/year (142 users) AWS IAM Identity Center: Free GuardDuty: $500/month = $6,000/year Access Analyzer: Free CloudTrail: $200/month = $2,400/year Session Manager: Free Total Technology: $13,500/year

Implementation Costs (One-Time): Policy documentation: 40 hours = $6,000 IAM setup and configuration: 80 hours = $12,000 Automation development: 120 hours = $18,000 Network architecture: 80 hours = $12,000 Testing and validation: 40 hours = $6,000 Total Implementation: $54,000

Ongoing Costs (Annual): Quarterly access reviews: 80 hours = $12,000 Monthly privileged reviews: 48 hours = $7,200 Annual policy review: 8 hours = $1,200 Incident investigation: 40 hours = $6,000 Total Ongoing: $26,400/year

Grand Total: $54,000 (one-time) + $39,900/year (technology + ongoing)


## Related Commands

- `/nist:control-tailor` - Customize specific controls
- `/nist:select-baseline` - Choose appropriate baseline
- `/nist:overlay-apply` - Apply FedRAMP or other overlays
- `/nist:ssp-section-generate` - Generate SSP documentation
- `/grc-engineer:generate-implementation` - Generate IaC for controls
- `/grc-engineer:test-control` - Test control effectiveness

NIST 800-53 Overlay Application

Applies overlay requirements from FedRAMP, DoD, Privacy, and other specialized frameworks to NIST 800-53 baselines, identifying additional controls, parameter changes, and implementation guidance.

Usage

/nist:overlay-apply <overlay-type> <baseline> [options]

Arguments

  • $1 - Overlay type: "fedramp", "dod", "privacy", "cmmc", "cjis", "hipaa", "irs-1075"
  • $2 - Base baseline: "low", "moderate", "high"
  • $3 - Options (optional): --output=table|ssp-text|yaml, --show-only-changes

Examples

# Apply FedRAMP Moderate overlay
/nist:overlay-apply fedramp moderate

# Apply DoD IL4 requirements
/nist:overlay-apply dod moderate

# Apply Privacy overlay
/nist:overlay-apply privacy moderate

# Show only additional requirements
/nist:overlay-apply fedramp moderate --show-only-changes

# Generate SSP-ready text
/nist:overlay-apply fedramp moderate --output=ssp-text

Output

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
NIST 800-53 OVERLAY APPLICATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Overlay: FedRAMP Moderate
Base Baseline: NIST 800-53 Rev 5 Moderate
Authorization Type: Agency ATO (initial)
Cloud Service Model: IaaS

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SUMMARY
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Baseline Controls: 325 controls
FedRAMP Additions: 28 controls
FedRAMP Removals: 0 controls (none)
Parameter Changes: 47 parameters
Total Required: 353 controls

Categorization:
  Low Impact: 0 controls (not applicable for Moderate)
  Moderate Impact: 353 controls
  High Impact: 0 controls (can optionally implement)

Impact Analysis:
  Effort Increase: +15% (28 additional controls)
  Cost Increase: +$35k-$50k (initial), +$15k/year (ongoing)
  Timeline Impact: +6-8 weeks (implementation)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FEDRAMP-SPECIFIC ADDITIONS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

HIGH PRIORITY (Must Implement Before Assessment):

+ AC-2(12) - Account Monitoring / Atypical Usage
  Requirement: Monitor for atypical account usage
  FedRAMP Rationale: Enhanced threat detection for government data
  Implementation:
    - CloudWatch anomaly detection for IAM activity
    - GuardDuty for threat detection
    - SIEM correlation rules (Splunk, DataDog)
  Effort: 24 hours
  Cost: $500/month (GuardDuty + CloudWatch)
  Evidence: GuardDuty findings, CloudWatch dashboards

+ AC-6(9) - Auditing Use of Privileged Functions
  Requirement: Log all privileged function execution
  FedRAMP Rationale: Government requires elevated privilege audit trail
  Implementation:
    - CloudTrail logging for all admin API calls
    - Separate log stream for privileged actions
    - Tamper-proof log storage (S3 Object Lock)
  Effort: 8 hours
  Cost: $50/month (additional CloudTrail storage)
  Evidence: CloudTrail logs showing privileged events

+ AU-3(1) - Full-Text Recording of Privileged Commands
  Requirement: Record full command text for privileged operations
  FedRAMP Rationale: Forensic analysis of admin actions
  Implementation:
    - CloudTrail records full API request/response
    - Session Manager logging for SSH/RDP sessions
    - S3 bucket for long-term storage (1 year)
  Effort: 12 hours
  Cost: $100/month (storage)
  Evidence: Session logs, API call records

+ AU-4(1) - Transfer to Alternate Storage
  Requirement: Transfer audit logs to alternate/independent storage
  FedRAMP Rationale: Prevent log tampering by admins
  Implementation:
    - Cross-region CloudTrail replication
    - Separate AWS account for log aggregation
    - S3 Object Lock (compliance mode, 1 year)
  Effort: 16 hours
  Cost: $200/month (cross-region transfer + storage)
  Evidence: S3 replication configuration, Object Lock proof

+ CA-7(3) - Trend Analyses
  Requirement: Perform security trend analysis
  FedRAMP Rationale: Proactive threat identification
  Implementation:
    - CloudWatch Insights queries (weekly)
    - GuardDuty trend reports (monthly)
    - Security dashboard with 30-day trends
  Effort: 32 hours
  Cost: $300/month (CloudWatch Insights)
  Evidence: Trend analysis reports, dashboards

+ CP-9(8) - Cryptographic Protection (Backups)
  Requirement: Encrypt backups with cryptographic mechanisms
  FedRAMP Rationale: Protect backup data confidentiality
  Implementation:
    - S3 default encryption (AES-256 or KMS)
    - RDS automated backups encrypted
    - EBS snapshot encryption enabled
  Effort: 4 hours (configuration only)
  Cost: $0 (encryption is free)
  Evidence: S3/RDS/EBS encryption configs

+ IA-2(1) - Multi-Factor Authentication (Network Access)
  Requirement: MFA for all network access
  FedRAMP Rationale: Stronger authentication for government systems
  Implementation:
    - Okta MFA for all users (TOTP or Push)
    - AWS SSO MFA enforcement
    - Disable password-only access
  Effort: 8 hours
  Cost: $3/user/month (Okta MFA)
  Evidence: Okta MFA enrollment reports, IAM MFA status

+ IA-2(2) - Multi-Factor Authentication (Non-Privileged Access)
  Requirement: MFA for non-privileged accounts too
  FedRAMP Rationale: FedRAMP requires MFA for ALL accounts
  Implementation:
    - Same as IA-2(1) - applies to all users
  Effort: Included in IA-2(1)
  Cost: Included
  Evidence: MFA enforcement policy + enrollment data

+ IA-2(8) - Access to Accounts – Replay Resistant
  Requirement: Prevent replay attacks on authentication
  FedRAMP Rationale: Protect against authentication token theft
  Implementation:
    - OAuth/OIDC with short-lived tokens (Okta)
    - Session tokens with nonce
    - TLS 1.2+ for all authentication traffic
  Effort: 4 hours (verify existing implementation)
  Cost: $0 (Okta handles this)
  Evidence: Okta OAuth configuration

+ IA-2(12) - Acceptance of PIV Credentials
  Requirement: Accept PIV/CAC cards (government smart cards)
  FedRAMP Rationale: Required for government user access
  Implementation:
    - Okta PKI integration for PIV/CAC
    - Certificate trust chain configuration
    - Fallback to MFA if no PIV card
  Effort: 40 hours (complex integration)
  Cost: $5,000 (Okta PKI add-on)
  Evidence: PIV authentication logs

+ IA-5(1) - Password-Based Authentication (Complexity)
  Requirement: Enhanced password requirements
  FedRAMP Parameters:
    - Minimum 15 characters (NIST baseline: 14)
    - Password history: 24 (NIST baseline: flexible)
    - Maximum age: 60 days (NIST removed this, but FedRAMP kept it)
  Implementation:
    - Okta password policy update
    - IAM password policy (for emergency accounts)
  Effort: 2 hours
  Cost: $0
  Evidence: Password policy screenshots

+ IR-5 - Incident Monitoring
  Requirement: Real-time incident tracking and reporting
  FedRAMP Rationale: Report incidents to FedRAMP within 1 hour
  Implementation:
    - PagerDuty integration for critical alerts
    - Automated incident ticket creation (Jira)
    - Notification to FedRAMP PMO (automated email)
  Effort: 16 hours
  Cost: $200/month (PagerDuty)
  Evidence: Incident response runbook, PagerDuty logs

+ IR-6(1) - Automated Reporting
  Requirement: Automate incident reporting
  FedRAMP Rationale: Timely reporting to FedRAMP
  Implementation:
    - GuardDuty → EventBridge → Lambda → Email/Jira
    - Automated FedRAMP incident notification
    - Slack integration for team awareness
  Effort: 12 hours
  Cost: $50/month (Lambda)
  Evidence: Lambda function code, sample incident reports

+ PE-3(1) - Information System Access - Video Surveillance
  Requirement: Video surveillance of physical facilities
  FedRAMP Rationale: Physical security for government data
  Implementation: N/A (cloud-only, AWS handles physical security)
  Cloud Provider: AWS physical security attestation
  Inherited: Yes (from AWS FedRAMP package)
  Evidence: AWS FedRAMP authorization letter

+ RA-5(5) - Privileged Access for Vulnerability Scanning
  Requirement: Credentialed vulnerability scans
  FedRAMP Rationale: More thorough vulnerability detection
  Implementation:
    - Amazon Inspector (agent-based, credentialed)
    - Tenable.io or Qualys integration (if 3PAO requires)
    - Weekly credentialed scans
  Effort: 16 hours
  Cost: $500/month (Inspector + optional Tenable)
  Evidence: Scan reports showing credentialed scans

+ SC-7(4) - Boundary Protection - External Telecommunications
  Requirement: Managed interfaces for external systems
  FedRAMP Rationale: Control all external connections
  Implementation:
    - VPC endpoints for AWS services (no internet)
    - Private NAT for outbound (controlled egress)
    - Transit Gateway for partner connections
  Effort: 24 hours
  Cost: $300/month (Transit Gateway)
  Evidence: VPC flow logs, network diagram

+ SC-7(5) - Boundary Protection - Deny by Default
  Requirement: Default deny for network traffic
  FedRAMP Rationale: Zero trust network architecture
  Implementation:
    - Security groups: default deny all inbound
    - NACLs: explicit allow only
    - WAF: deny all, allow specific
  Effort: 8 hours
  Cost: $50/month (WAF)
  Evidence: Security group configs showing default deny

+ SC-12(1) - Cryptographic Key Availability
  Requirement: Ensure cryptographic keys available when needed
  FedRAMP Rationale: Prevent data loss due to key unavailability
  Implementation:
    - KMS multi-region keys
    - Key backup to separate region
    - Documented key recovery process
  Effort: 12 hours
  Cost: $50/month (additional KMS keys)
  Evidence: KMS key policies, backup documentation

+ SC-13 - Cryptographic Protection (FedRAMP Approved Algorithms)
  Requirement: Use only FIPS 140-2 validated cryptography
  FedRAMP Parameters: AES-256, RSA-2048+, SHA-256+
  Implementation:
    - KMS uses FIPS 140-2 validated modules
    - TLS 1.2+ only (no TLS 1.0/1.1)
    - S3/RDS encryption uses AES-256
  Effort: 4 hours (verify, document)
  Cost: $0
  Evidence: FIPS validation certificates

+ SC-28(1) - Cryptographic Protection of Information at Rest
  Requirement: Encrypt all data at rest
  FedRAMP Rationale: Protect government data confidentiality
  Implementation:
    - S3 default encryption (AES-256)
    - RDS encryption at rest
    - EBS volume encryption
    - Secrets Manager encryption
  Effort: 8 hours
  Cost: $0 (encryption is free)
  Evidence: Encryption configuration screenshots

+ SI-2(2) - Automated Flaw Remediation Status
  Requirement: Automate tracking of patch status
  FedRAMP Rationale: Demonstrate timely patching
  Implementation:
    - AWS Systems Manager Patch Manager
    - Automated compliance reporting
    - Dashboard showing patch compliance %
  Effort: 16 hours
  Cost: $100/month (SSM)
  Evidence: Patch compliance reports

+ SI-3(1) - Central Management (Malware)
  Requirement: Centrally manage malware detection
  FedRAMP Rationale: Consistent protection across systems
  Implementation:
    - GuardDuty (AWS-native, auto-enabled)
    - CrowdStrike or Trend Micro (if EC2 workloads)
    - Central dashboard for all alerts
  Effort: 20 hours
  Cost: $1,000/month (3rd party AV)
  Evidence: GuardDuty + AV console screenshots

+ SI-4(2) - Automated Tools for Real-Time Analysis
  Requirement: Real-time security event analysis
  FedRAMP Rationale: Rapid threat detection and response
  Implementation:
    - GuardDuty (real-time analysis)
    - CloudWatch Logs Insights (real-time queries)
    - SIEM correlation (Splunk, real-time)
  Effort: 32 hours
  Cost: $1,500/month (SIEM)
  Evidence: Real-time alerting examples

+ SI-4(5) - System-Generated Alerts
  Requirement: Automated security alerts
  FedRAMP Rationale: Timely notification of security events
  Implementation:
    - CloudWatch alarms → SNS → Slack/PagerDuty
    - GuardDuty findings → EventBridge → Lambda
    - Security Hub aggregation
  Effort: 12 hours
  Cost: $200/month (PagerDuty)
  Evidence: Alert examples, PagerDuty integration

+ SI-4(23) - Host-Based Devices
  Requirement: Host-based monitoring on systems
  FedRAMP Rationale: Endpoint visibility
  Implementation:
    - CloudWatch agent on all EC2 instances
    - SSM agent for inventory
    - Optional: CrowdStrike EDR
  Effort: 16 hours
  Cost: $500/month (CrowdStrike)
  Evidence: Agent deployment status

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PARAMETER CHANGES (FedRAMP vs NIST Baseline)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

More Restrictive Parameters:

AC-2(j) - Account Review Frequency
  NIST Moderate: "Organization-defined frequency"
  FedRAMP: "At least annually"
  RECOMMENDED: Quarterly (exceeds FedRAMP, matches PCI)

AU-11 - Audit Record Retention
  NIST Moderate: "Organization-defined time period"
  FedRAMP: "At least 90 days online, 1 year total"
  RECOMMENDED: 365 days online (easier compliance)

IA-5(1) - Password Requirements
  NIST Moderate: 14 characters minimum
  FedRAMP: 15 characters minimum + 60-day max age
  IMPLEMENTATION: 15 chars, 90-day age (balanced)

SC-28 - Data at Rest Encryption
  NIST Moderate: "Organization-defined information at rest"
  FedRAMP: "ALL data at rest must be encrypted"
  IMPLEMENTATION: Default encryption on all storage

SI-2 - Flaw Remediation Timeline
  NIST Moderate: "Organization-defined time period"
  FedRAMP: "Within 30 days (high), 60 days (moderate)"
  IMPLEMENTATION: 30 days for all (best practice)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FEDRAMP DOCUMENTATION REQUIREMENTS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Required Deliverables:

1. System Security Plan (SSP)
   - FedRAMP template (300+ pages typical)
   - All 353 controls documented
   - Control implementation details
   - Evidence attachments
   Tool: /nist:ssp-section-generate

2. Security Assessment Plan (SAP)
   - Provided by 3PAO (Third Party Assessment Organization)
   - Review and approve
   - Identify testable assertions

3. Security Assessment Report (SAR)
   - Created by 3PAO after testing
   - Documents findings (open, risk-adjusted)
   - Remediation plans

4. Plan of Action & Milestones (POA&M)
   - All open findings
   - Remediation timeline
   - Risk ratings
   - Monthly updates required

5. Incident Response Plan
   - FedRAMP-specific requirements
   - 1-hour notification to FedRAMP PMO
   - Templates provided by FedRAMP

6. Configuration Management Plan
   - Baseline configurations
   - Change management process
   - Version control

7. Continuous Monitoring Plan
   - Monthly vulnerability scans (required)
   - Annual penetration test
   - Monthly security metrics to FedRAMP

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FEDRAMP AUTHORIZATION PROCESS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Step 1: Readiness Assessment (2-3 months, $75k-$150k)
  - Self-assessment against FedRAMP controls
  - Gap remediation
  - Documentation preparation
  - Pre-assessment by 3PAO (optional, recommended)

Step 2: 3PAO Assessment (3-4 months, $150k-$300k)
  - Kickoff and planning
  - Documentation review
  - Testing (design + operating effectiveness)
  - SAR creation

Step 3: Agency ATO (1-3 months, varies)
  - Submit package to agency
  - Agency review and acceptance
  - ConMon agreement
  - ATO issuance

Total Timeline: 6-10 months
Total Cost: $225k-$450k (initial), $100k-$200k/year (ConMon)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
INHERITED CONTROLS (from AWS)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

FedRAMP allows inheritance from AWS (already FedRAMP authorized):

Physical Controls (fully inherited):
  - PE-2: Physical Access Authorizations
  - PE-3: Physical Access Control
  - PE-6: Monitoring Physical Access
  - PE-8: Visitor Access Records
  - PE-13: Fire Protection
  - PE-14: Temperature and Humidity Controls
  - PE-15: Water Damage Protection

Environmental Controls:
  - PE-9: Power Equipment and Cabling
  - PE-10: Emergency Shutoff
  - PE-11: Emergency Power
  - PE-12: Emergency Lighting

Evidence: AWS FedRAMP authorization package (publicly available)
Your Responsibility: Reference AWS package, include inheritance table

Shared Controls (partial inheritance):
  - CA-3: System Interconnections (AWS provides infrastructure, you document)
  - CM-2: Baseline Configuration (AWS + your application)
  - RA-2: Security Categorization (AWS + your data)
  - SA-9: External Information Systems (AWS + your 3rd parties)

Customer Responsibility (no inheritance):
  - AC-*: Access Control (your application users)
  - AU-*: Audit Logging (your application logs)
  - IA-*: Identification and Authentication (your users)
  - SC-7: Boundary Protection (your VPC configuration)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CONTINUOUS MONITORING REQUIREMENTS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Monthly Deliverables to FedRAMP:

1. Vulnerability Scan Results
   - Authenticated scans (all assets)
   - Credentialed scans required
   - POA&M for findings >30 days old

2. POA&M Updates
   - All open findings
   - Status updates
   - Risk ratings

3. Incident Summary
   - All security incidents
   - Root cause analysis for P1/P2
   - Remediation status

4. Change Requests
   - Significant changes require approval
   - Examples: new services, architecture changes
   - Submit via FedRAMP portal

Annual Requirements:

1. Security Assessment
   - Full re-assessment every 3 years
   - Annual self-assessment in between
   - Penetration test

2. ISSO Review
   - Information System Security Officer
   - Annual review of all controls
   - Sign-off on continued effectiveness

Automation:
```bash
# Set up continuous monitoring
/nist:continuous-monitoring-setup fedramp

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ COST SUMMARY ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Initial Authorization: Readiness Assessment: $75,000 - $150,000 Gap Remediation (IaC): $25,000 - $50,000 3PAO Assessment: $150,000 - $300,000 Documentation (internal): $40,000 (400 hours @ $100/hr) Misc (tools, training): $10,000 TOTAL INITIAL: $300,000 - $550,000

Ongoing (Annual): 3PAO Annual Assessment: $75,000 - $125,000 Monthly ConMon: $15,000 - $30,000 Vuln Scanning (monthly): $12,000 Incident Response (retainer): $10,000 TOTAL ANNUAL: $112,000 - $177,000

Technology Costs (Annual): GuardDuty: $6,000 Inspector: $6,000 CloudWatch (enhanced): $3,600 PagerDuty: $2,400 Okta PKI (PIV): $5,000 SIEM (Splunk/DataDog): $18,000 TOTAL TECH: $41,000/year

GRAND TOTAL: $300k-$550k (initial) + $153k-$218k/year (ongoing)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ RECOMMENDATIONS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Before Starting FedRAMP:

  1. Ensure NIST 800-53 Moderate compliance (baseline)
  2. Complete gap remediation for 28 additional controls
  3. Select and engage 3PAO (get quotes from 3+)
  4. Budget appropriately ($300k-$550k initial)
  5. Allocate internal resources (400-800 hours)

Quick Wins (Implement First):

  1. SC-28(1) - Data at rest encryption ($0 cost, 8 hours)
  2. IA-5(1) - Update password policy ($0 cost, 2 hours)
  3. SI-2(2) - Patch Manager ($100/month, 16 hours)
  4. AU-4(1) - Cross-region log replication ($200/month, 16 hours)

High Impact:

  1. IA-2(12) - PIV/CAC support ($5k, 40 hours) - REQUIRED for gov users
  2. CA-7(3) - Trend analysis ($300/month, 32 hours)
  3. RA-5(5) - Credentialed scanning ($500/month, 16 hours)

Generate Implementation Code:

# Identify gaps
/nist:overlay-apply fedramp moderate --show-only-changes > gaps.txt

# Generate IaC to fix
/grc-engineer:generate-implementation AC-2 aws
/grc-engineer:generate-implementation AU-4 aws
# ... for each gap

# Or use SOC2 gap-to-code
/soc2:gap-to-code gaps.json aws --output-dir=./fedramp-remediation

## Other Overlays

### DoD Impact Level 4 (IL4)

Similar to FedRAMP High, with additional DoD-specific requirements:
- DISA STIGs compliance
- DoD-approved cryptography only
- Additional logging requirements
- Cleared personnel requirements

### Privacy Overlay

Adds privacy-specific controls:
- AP-1: Authority to Collect PII
- AP-2: Purpose Specification
- AR-*: Accountability, Audit, and Risk Management family
- DI-*: Data Quality and Integrity family
- IP-*: Individual Participation family

### CMMC (Cybersecurity Maturity Model Certification)

Maps NIST 800-53 to CMMC levels:
- Level 1: Basic Cyber Hygiene (17 practices)
- Level 2: Intermediate (110 practices, aligns with NIST 800-171)
- Level 3: Good Cyber Hygiene (130 practices, subset of NIST 800-53)

## Related Commands

- `/nist:control-tailor` - Tailor individual controls
- `/nist:select-baseline` - Select appropriate baseline
- `/nist:ssp-section-generate` - Generate SSP text
- `/fedramp:assess` - FedRAMP-specific assessment
- `/grc-engineer:generate-implementation` - Generate IaC for gaps

Select NIST Baseline

Helps select and tailor a NIST 800-53 baseline for your system.

Arguments

  • $1 - Impact level (required: low, moderate, high)
  • $2 - System type (optional: general, cloud, mobile, industrial)

Baselines

Low Impact

  • ~125 controls
  • Basic security requirements
  • Suitable for non-sensitive systems

Moderate Impact

  • ~325 controls
  • Enhanced security requirements
  • Most common for federal systems

High Impact

  • ~425 controls
  • Maximum security requirements
  • National security systems

Tailoring Options

  • Scoping: Remove non-applicable controls
  • Compensating: Substitute equivalent controls
  • Organization-defined: Set parameters
  • Overlays: Apply specific requirements (privacy, cloud)

Example

/nist:select-baseline moderate cloud

NIST 800-53 SSP Section Generator

Generates production-ready System Security Plan (SSP) sections for NIST 800-53 controls, including control statements, implementation details, responsible roles, and evidence references in compliance with FedRAMP and NIST templates.

Usage

/nist:ssp-section-generate <control-id> [template] [options]

Arguments

  • $1 - Control ID (e.g., "AC-2", "AU-2") or family (e.g., "AC", "AU")
  • $2 - Template (optional): "fedramp", "nist", "dod", "custom" (default: "fedramp")
  • $3 - Options (optional): --format=docx|markdown|yaml, --include-evidence

Examples

# Generate single control SSP section
/nist:ssp-section-generate AC-2 fedramp

# Generate entire family
/nist:ssp-section-generate AC fedramp

# Export as Word document
/nist:ssp-section-generate AC-2 fedramp --format=docx

# Include evidence references
/nist:ssp-section-generate AC-2 fedramp --include-evidence

Output

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SSP SECTION: AC-2 - ACCOUNT MANAGEMENT
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Template: FedRAMP Rev 5 Moderate
System: Your Company Cloud Platform
Date: 2025-01-28

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CONTROL SUMMARY
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Control Identifier: AC-2
Control Name: Account Management
Control Family: Access Control (AC)
Baseline: Moderate
Implementation Status: Implemented
Responsible Role: Information Security, IT Operations
Implementation Date: January 2024

Control Enhancements:
  ✓ AC-2(1) - Automated System Account Management
  ✓ AC-2(2) - Removal of Temporary / Emergency Accounts
  ✓ AC-2(3) - Disable Inactive Accounts
  ✓ AC-2(4) - Automated Audit Actions
  ✓ AC-2(9) - Restrictions on Use of Shared Groups / Accounts
  ✓ AC-2(12) - Account Monitoring / Atypical Usage (FedRAMP)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PART A: CONTROL REQUIREMENT (FEDRAMP)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

AC-2: Account Management

The organization:

a. Identifies and selects the following types of information system accounts
   to support organizational missions/business functions: [Assignment:
   organization-defined information system account types];

b. Assigns account managers for information system accounts;

c. Establishes conditions for group and role membership;

d. Specifies authorized users of the information system, group and role
   membership, and access authorizations (i.e., privileges) and other
   attributes (as required) for each account;

e. Requires approvals by [Assignment: organization-defined personnel or roles]
   for requests to create information system accounts;

f. Creates, enables, modifies, disables, and removes information system
   accounts in accordance with [Assignment: organization-defined procedures
   or conditions];

g. Monitors the use of information system accounts;

h. Notifies account managers:
    1. When accounts are no longer required;
    2. When users are terminated or transferred; and
    3. When individual information system usage or need-to-know changes;

i. Authorizes access to the information system based on:
    1. A valid access authorization;
    2. Intended system usage; and
    3. Other attributes as required by the organization or associated missions/
       business functions;

j. Reviews accounts for compliance with account management requirements
   [Assignment: organization-defined frequency]; and

k. Establishes a process for reissuing shared/group account credentials
   (if deployed) when individuals are removed from the group.

Control Enhancements:

AC-2(1): The organization employs automated mechanisms to support the management
         of information system accounts.

AC-2(2): The information system automatically [Selection: removes; disables]
         temporary and emergency accounts after [Assignment: organization-
         defined time period for each type of account].

AC-2(3): The information system automatically disables inactive accounts after
         [Assignment: organization-defined time period].

AC-2(4): The information system automatically audits account creation,
         modification, enabling, disabling, and removal actions, and notifies
         [Assignment: organization-defined personnel or roles].

AC-2(9): The organization only permits the use of shared/group accounts that
         meet [Assignment: organization-defined conditions for establishing
         shared/group accounts].

AC-2(12): The organization: (a) Monitors information system accounts for
          [Assignment: organization-defined atypical use]; and (b) Reports
          atypical usage of information system accounts to [Assignment:
          organization-defined personnel or roles].

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PART B: CONTROL IMPLEMENTATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

AC-2: Account Management

Your Company manages information system accounts for the [System Name] through
automated provisioning integrated with our authoritative HR system (BambooHR)
and enterprise identity provider (Okta). This control ensures that access to
organizational information systems is appropriately authorized, monitored, and
reviewed.

AC-2(a) - Account Types

Your Company maintains the following account types to support organizational
missions and business functions:

  1. Workforce Accounts (Individual User Accounts)
     - Purpose: Daily operational access for employees and contractors
     - Authentication: Federated via Okta SSO to AWS IAM Identity Center
     - Lifecycle: Created upon hire, disabled upon termination
     - Count: Approximately 142 active users (as of December 2024)
     - Naming Convention: firstname.lastname@company.com

  2. Service Accounts (Application Accounts)
     - Purpose: Automated system-to-system communication
     - Implementation: AWS IAM roles (not user accounts)
     - Examples: Lambda execution roles, ECS task roles, EC2 instance profiles
     - Count: 23 active service roles
     - Naming Convention: service-[app-name]-[environment]

  3. Emergency Access Accounts (Break-Glass Accounts)
     - Purpose: Emergency access when SSO unavailable
     - Implementation: IAM users with MFA, normally disabled
     - Approval: CISO approval required for creation and use
     - Expiration: Automatically disabled after 72 hours
     - Count: 2 accounts (root alternative, emergency admin)

  4. Contractor Accounts (Temporary Accounts)
     - Purpose: Short-term access for consultants and vendors
     - Authentication: Federated via Okta (same as workforce)
     - Expiration: Maximum 6-month duration, extended only with approval
     - Count: Variable (5-10 active at any time)

AC-2(b) - Account Managers

Account managers are assigned based on organizational structure and account type:

  - Workforce Accounts: Managed by IT Operations team
    Contact: it-ops@company.com
    Responsibilities: Provisioning, access reviews, compliance monitoring

  - Service Accounts: Managed by application development teams
    Contact: Application owners (documented in Jira)
    Responsibilities: Role creation, permission assignment, quarterly review

  - Emergency Access Accounts: Managed by CISO
    Contact: ciso@company.com
    Responsibilities: Creation approval, usage monitoring, incident review

  - Contractor Accounts: Managed by hiring manager + IT Operations
    Contact: Manager who requested access
    Responsibilities: Approval, access review, termination notification

AC-2(c) - Group and Role Membership

Group and role membership is established using role-based access control (RBAC)
aligned with job functions. Groups are defined in Okta and synchronized to AWS
IAM Identity Center permission sets.

  Standard Roles:
    - Developer: Read/write access to dev environment, read-only to prod
    - QA Engineer: Read/write access to QA environment, read-only to dev/prod
    - DevOps Engineer: Full access to all environments (with approval)
    - Data Analyst: Read-only access to analytics databases
    - Support Engineer: Read-only access to production logs and metrics

  Privileged Roles (require additional approval):
    - Administrator: Full access to AWS management console
    - Security Analyst: Access to security tooling (GuardDuty, Security Hub)
    - Database Administrator: Write access to production databases

  Group membership conditions are documented in the Access Control Policy v1.8,
  section 4.2 "Role-Based Access Control Matrix."

AC-2(d) - Authorized Users and Privileges

Authorized users of the information system, their group/role membership, and
access authorizations are specified and documented in Okta as the authoritative
source of identity. Access privileges are mapped to AWS IAM Identity Center
permission sets.

  Process:
    1. User identity established in BambooHR (upon hire)
    2. Manager specifies required access via Jira Service Desk ticket
    3. IT Operations validates against RBAC matrix
    4. Access provisioned in Okta (synchronized to AWS within 15 minutes)
    5. User receives welcome email with MFA enrollment instructions

  Attributes maintained for each account:
    - Full name, email address, employee ID
    - Department, manager, job title
    - Group memberships (Okta groups)
    - Permission sets (AWS IAM Identity Center)
    - Account status (active, suspended, disabled)
    - MFA enrollment status
    - Last login date

AC-2(e) - Approval Requirements

Requests to create information system accounts require approval based on the
following matrix:

  Standard User Accounts:
    - Approval Required: Direct manager
    - Method: Jira Service Desk ticket with manager approval
    - SLA: 4 business hours

  Privileged User Accounts:
    - Approval Required: Direct manager + CISO
    - Method: Jira ticket + email to ciso@company.com
    - Justification: Business need documented in ticket
    - SLA: 24 business hours

  Service Accounts (IAM Roles):
    - Approval Required: Application owner + Security team
    - Method: Terraform pull request with approvers
    - Review: Security team reviews IAM permissions for least privilege
    - SLA: 48 business hours

  Emergency Access Accounts:
    - Approval Required: CISO only
    - Method: Email request with justification
    - Review: Incident post-mortem required after use
    - SLA: 1 business hour (emergency only)

AC-2(f) - Account Lifecycle Procedures

Information system accounts are created, enabled, modified, disabled, and
removed in accordance with the following automated procedures:

  Account Creation:
    1. HR creates employee record in BambooHR
    2. Manager submits access request via Jira Service Desk
    3. Automated workflow validates approval
    4. Okta account provisioned automatically (via BambooHR integration)
    5. AWS SSO account created (via Okta SCIM integration)
    6. User receives welcome email with MFA enrollment link
    7. Ticket closed automatically after successful provisioning
    Evidence: Jira ticket, Okta audit log, CloudTrail IAM events

  Account Modification:
    1. Manager submits modification request via Jira
    2. IT Operations reviews and approves
    3. Okta group membership updated manually or via API
    4. AWS permission sets updated automatically (SCIM sync)
    5. User notified of access change via email
    Evidence: Jira ticket, Okta audit log

  Account Disable (Termination):
    1. HR marks employee as terminated in BambooHR
    2. BambooHR webhook triggers automated workflow (n8n)
    3. Okta account disabled within 4 hours (Lambda function)
    4. AWS SSO access revoked automatically (SCIM sync)
    5. Notification sent to IT Operations and manager
    6. Access keys rotated for any services the user had access to
    Evidence: BambooHR termination date, Okta audit log, CloudTrail

  Account Removal:
    1. Disabled accounts reviewed after 90 days
    2. If no reactivation needed, account deleted from Okta
    3. AWS SSO account removed (SCIM sync)
    4. Final backup of user's data (if applicable)
    Evidence: Quarterly cleanup reports

AC-2(g) - Account Usage Monitoring

The use of information system accounts is monitored through multiple mechanisms:

  Real-Time Monitoring:
    - AWS CloudTrail: All IAM and AWS API activity logged
    - Amazon GuardDuty: Threat detection and anomaly analysis
    - Okta System Log: All authentication and authorization events

  Daily Monitoring:
    - IAM credential report generated daily (last login dates)
    - Inactive account detection (>90 days no login)
    - Failed login attempt analysis (brute force detection)

  Monthly Monitoring:
    - Privileged access usage review (administrator actions)
    - Excessive permission usage (unused IAM permissions)

  Automated Alerts:
    - Unusual login location or time (GuardDuty finding)
    - Privilege escalation attempts (CloudTrail alarm)
    - Multiple failed login attempts (Okta alert)
    - Dormant account reactivation (after 60+ days inactive)

AC-2(h) - Account Manager Notifications

Account managers are notified automatically in the following scenarios:

  When accounts are no longer required:
    - Quarterly access review report lists all accounts under their purview
    - Manager must attest that each account is still needed
    - Unattested accounts flagged for review

  When users are terminated or transferred:
    - Immediate Slack notification to manager and IT Operations
    - Email summary of access removed
    - Confirmation that all access was revoked within SLA

  When usage or need-to-know changes:
    - Role change detected in BambooHR triggers access review
    - Manager receives email to re-certify required access
    - Automated comparison of new role vs. current permissions

AC-2(i) - Access Authorization Criteria

Access to the information system is authorized based on:

  Valid Access Authorization:
    - Approved Jira Service Desk ticket
    - Manager approval documented
    - Security team approval (if privileged access)

  Intended System Usage:
    - Job function documented in BambooHR
    - Business need articulated in access request
    - Alignment with RBAC matrix

  Other Attributes:
    - Active employment status (verified via BambooHR)
    - MFA enrollment completed
    - Security awareness training completed (annual requirement)
    - Background check completed (for privileged access only)

AC-2(j) - Account Review Frequency

Accounts are reviewed for compliance with account management requirements on
the following schedule:

  Quarterly Reviews (every 90 days):
    - All workforce accounts reviewed by managers
    - Service accounts reviewed by application owners
    - Attestation that access is still required and appropriate
    - Removal of unnecessary access
    - Documentation: Quarterly access review reports

  Monthly Reviews (every 30 days):
    - Privileged accounts (administrators, database admins)
    - Reviewed by CISO
    - Verification of continued business need
    - Documentation: Monthly privileged access review

  Daily Automated Checks:
    - Inactive accounts (>90 days no login)
    - Emergency accounts (>72 hours enabled)
    - Accounts without MFA enrollment
    - Documentation: Daily automated reports

AC-2(k) - Shared Account Credential Reissuance

Your Company policy prohibits shared user accounts. Service accounts (AWS IAM
roles) are used where multiple systems need equivalent access, but these do not
use static credentials.

  For the limited cases where service account credentials exist:
    - Stored in AWS Secrets Manager
    - Automatic rotation enabled (30-day rotation)
    - Manual rotation triggered when team membership changes
    - Notification sent to all users with access after rotation
    - Audit trail maintained in Secrets Manager

  Process:
    1. Team membership change detected (user added or removed from group)
    2. EventBridge rule triggers Lambda function
    3. Secrets Manager automatic rotation initiated
    4. New credentials propagated to services
    5. Old credentials invalidated
    6. Notification sent to application owner
    Evidence: Secrets Manager rotation logs

Control Enhancement Implementations:

AC-2(1) - Automated System Account Management

Your Company employs the following automated mechanisms to support account
management:

  Provisioning Automation:
    - Okta provisioning API (SCIM 2.0 to AWS IAM Identity Center)
    - BambooHR to Okta integration (user lifecycle)
    - Terraform for IAM role creation and management

  Deprovisioning Automation:
    - Lambda function: deprovision-user (triggered by BambooHR webhook)
    - Executes within 4 hours of termination event
    - Disables Okta account, revokes AWS sessions, deactivates access keys

  Monitoring Automation:
    - Lambda function: check-inactive-accounts (daily execution)
    - EventBridge rule: detect emergency account age >72 hours
    - AWS Config rule: detect IAM users without MFA

  Evidence: Lambda function source code, CloudTrail execution logs

AC-2(2) - Removal of Temporary / Emergency Accounts

The information system automatically disables temporary and emergency accounts
after the following time periods:

  Emergency Access Accounts:
    - Time Period: 72 hours
    - Implementation: EventBridge rule triggers Lambda daily
    - Action: Disable IAM user, send notification to CISO
    - Override: CISO can extend for additional 72 hours (documented)

  Contractor Accounts:
    - Time Period: 6 months (180 days)
    - Implementation: Okta user object has expiration date attribute
    - Action: Okta lifecycle policy auto-disables on expiration
    - Extension: Manager can request extension via Jira (requires justification)

  Evidence: Lambda function logs, Okta lifecycle policy configuration

AC-2(3) - Disable Inactive Accounts

The information system automatically disables inactive accounts after 90 days
of inactivity.

  Implementation:
    - Daily Lambda function: check-inactive-accounts
    - Data source: IAM credential report (last login date)
    - Warning: Email to user and manager after 75 days inactive
    - Action: Disable account after 90 days
    - Notification: Email to manager confirming disable
    - Reactivation: User can request reactivation via Jira

  Exceptions:
    - Service accounts (IAM roles) excluded (no interactive login)
    - Emergency accounts already covered by AC-2(2)

  Evidence: IAM credential reports (daily), disable action logs

AC-2(4) - Automated Audit Actions

The information system automatically audits all account management actions and
notifies designated personnel:

  Audit Logging:
    - AWS CloudTrail logs all IAM API calls
    - Okta System Log records all account changes
    - Logs retained for 365 days online, 3 years total

  Notification Recipients:
    - Account creation: IT Operations (Slack notification)
    - Account deletion: CISO + IT Operations (email)
    - Privilege escalation: CISO + Security team (PagerDuty alert)
    - Failed login attempts (>5): User + manager (email)

  Automated Notifications:
    - EventBridge rule filters CloudTrail for IAM events
    - Lambda function formats notification
    - SNS topic publishes to Slack + email

  Evidence: CloudTrail logs, SNS delivery logs, Slack message archive

AC-2(9) - Restrictions on Use of Shared/Group Accounts

Your Company only permits the use of shared/group accounts under the following
conditions:

  Conditions for Shared Accounts:
    1. Service accounts only (not for human users)
    2. Implemented as AWS IAM roles (temporary credentials)
    3. Approved by Security team
    4. Documented in service account registry
    5. Credentials stored in AWS Secrets Manager
    6. Automatic rotation enabled

  Prohibited:
    - Shared human user accounts (enforce unique accounts for all personnel)
    - Generic accounts (admin, root, etc.)
    - Group accounts without audit trail

  Enforcement:
    - Okta policy prohibits account sharing
    - AWS Config rule detects IAM users with shared access keys
    - Automated alert if policy violation detected

  Evidence: Access Control Policy (section 3.4), Config rule results

AC-2(12) - Account Monitoring / Atypical Usage (FedRAMP Addition)

Your Company monitors information system accounts for the following atypical
usage scenarios and reports to designated personnel:

  Atypical Usage Scenarios Monitored:
    - Login from unusual geographic location (outside US)
    - Login at unusual time (outside business hours)
    - Excessive API calls (rate limiting)
    - Privilege escalation attempts
    - Access to data outside normal scope
    - Use of emergency accounts (always atypical)

  Monitoring Mechanisms:
    - Amazon GuardDuty: Anomaly-based threat detection
    - Okta ThreatInsight: IP reputation and anomaly detection
    - CloudWatch Anomaly Detection: API call volume analysis
    - Custom Lambda: Detect after-hours privileged access

  Reporting:
    - Real-time: GuardDuty findings → EventBridge → PagerDuty (P1/P2 findings)
    - Daily: Summary email to Security team (all findings)
    - Weekly: Trend analysis report to CISO
    - Monthly: Metrics dashboard for management review

  Response Process:
    1. Alert generated by monitoring system
    2. Security team investigates (within 15 minutes for high severity)
    3. User contacted if needed
    4. Account disabled if confirmed malicious activity
    5. Incident ticket created
    6. Root cause analysis performed

  Evidence: GuardDuty findings, PagerDuty incident logs, investigation tickets

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PART C: RESPONSIBLE ROLES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Implementation:
  - Information Security (CISO, Security Analysts)
  - IT Operations (Identity & Access Management team)
  - Engineering (DevOps, Platform Engineering)

Oversight:
  - CISO
  - VP Engineering

Assessment:
  - Internal Audit
  - Third Party Assessor (3PAO)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PART D: IMPLEMENTATION EVIDENCE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Policy and Procedures:
  - Access Control Policy v1.8 (approved 2024-01-15)
  - User Provisioning Procedure v1.2 (approved 2024-01-10)
  - User Deprovisioning Procedure v1.3 (approved 2024-01-10)
  - Access Review Procedure v1.1 (approved 2024-01-05)

Configuration Evidence:
  - Okta to AWS SSO integration configuration
  - BambooHR to Okta integration documentation
  - Lambda function: deprovision-user (source code)
  - Lambda function: check-inactive-accounts (source code)
  - EventBridge rules: emergency-account-age-check
  - AWS Config rules: iam-user-mfa-enabled

Testing Evidence:
  - Automated control tests: /grc-engineer:test-control AC-2
    - Test results from 2024-12-28: 14/15 tests passed (93%)
  - Quarterly access reviews (2024 Q1-Q4)
  - Monthly privileged access reviews (2024)

Operational Evidence:
  - IAM user list (quarterly snapshots): 2024-Q1 through Q4
  - IAM credential reports (monthly): January 2024 - December 2024
  - CloudTrail logs (full year): 2024-01-01 to 2024-12-31
  - Jira access request tickets (sample 25 from 2024)
  - Termination evidence (all 12 terminations in 2024)
  - GuardDuty findings (2024 full year)

Audit Evidence:
  - Annual penetration test (2024-11-15)
  - Quarterly vulnerability scans (2024 Q1-Q4)
  - Control effectiveness testing results (from 3PAO assessment)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PART E: CUSTOMER RESPONSIBILITIES (CRMs)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Customer Responsibilities:

If your organization uses our service, you are responsible for:

1. Managing your application-level user accounts
2. Implementing appropriate access controls within your applications
3. Reviewing application user access periodically
4. Notifying us of terminated users who should lose access
5. Monitoring your users' activities within the application

Your Company provides:
  - API for user management
  - Audit logs of user activities
  - Documentation for implementing access controls

Related Commands

  • /nist:control-tailor - Customize control implementation
  • /nist:overlay-apply - Apply FedRAMP or other overlays
  • /nist:family-deep-dive - Detailed guidance on AC family
  • /soc2:evidence-checklist - Collect required evidence
  • /grc-engineer:test-control - Test control effectiveness

Sponsors

Details

Marketplace
GRCEngClub/claude-grc-engineering
Source
plugins/frameworks/nist-800-53
Category
Community

More from GRCEngClub/claude-grc-engineering

All 70