
nist-800-53
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-suiteRun it inside Claude Code after adding the marketplace with /plugin marketplace add GRCEngClub/claude-grc-engineering.
Contents
Discovered from sourceSkills 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
| ID | Family |
|---|---|
| AC | Access Control |
| AT | Awareness and Training |
| AU | Audit and Accountability |
| CA | Assessment, Authorization, and Monitoring |
| CM | Configuration Management |
| CP | Contingency Planning |
| IA | Identification and Authentication |
| IR | Incident Response |
| MA | Maintenance |
| MP | Media Protection |
| PE | Physical and Environmental Protection |
| PL | Planning |
| PM | Program Management |
| PS | Personnel Security |
| PT | PII Processing and Transparency |
| RA | Risk Assessment |
| SA | System and Services Acquisition |
| SC | System and Communications Protection |
| SI | System and Information Integrity |
| SR | Supply 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:
-
Vulnerability Scan Report
- Generated: 5th of each month
- Source: Tenable/Inspector
- Format: PDF + CSV
- Upload: FedRAMP Secure Repository (FSR)
-
Plan of Action & Milestones (POA&M)
- All open findings
- Status updates
- Remediation timeline
- Risk ratings
-
Incident Summary
- All P1/P2 incidents
- Root cause analysis
- Remediation actions
- Lessons learned
-
Change Log
- All significant changes (architecture, new services)
- Change approval evidence
- Rollback plans
-
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:
- Implement AC-2(1), AC-2(2), AC-2(3), AC-2(4) (core enhancements)
- Generate IaC for implementation: /soc2:gap-to-code gaps.json aws
- Document tailoring decisions in SSP
- Update Access Control Policy with tailored parameters
Within 3 Months:
- Consider AC-2(9) if shared accounts still exist
- Evaluate AC-2(12) for enhanced monitoring
- Review if AC-2(7) needed (separate privileged accounts)
Continuous:
- Test control effectiveness: /grc-engineer:test-control AC-2
- Review tailoring decisions annually
- 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.
.gitignorecoversevidence/by default sogit add -Awill 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, orhigh. 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, orcsv. 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)
- Create test user in BambooHR
- Verify Okta account created within 15 minutes
- Verify AWS SSO access granted
- Verify email notification sent to user Expected Result: Automated provisioning successful
Test 2: Account Termination (AC-2)
- Mark test user as terminated in BambooHR
- Verify Okta account disabled within 4 hours
- Verify AWS SSO access revoked
- Verify CloudTrail logs termination event Expected Result: Automated deprovisioning successful
Test 3: Access Enforcement (AC-3)
- Attempt to access resource without permission
- Verify access denied
- Verify denial logged in CloudTrail Expected Result: Access denied, audit trail created
Test 4: Least Privilege (AC-6)
- Review IAM policies for overly broad permissions
- Run Access Analyzer to detect unused permissions
- Verify no users have AdministratorAccess (except break-glass) Expected Result: All users follow least privilege
Test 5: Session Lock (AC-11)
- Log in to AWS console
- Wait 15 minutes without activity
- Attempt to perform action Expected Result: Session expired, re-authentication required
Test 6: Remote Access (AC-17)
- Attempt direct SSH to EC2 instance
- Verify SSH blocked (no public IPs, no key-based auth)
- Use Session Manager to connect
- 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:
- Ensure NIST 800-53 Moderate compliance (baseline)
- Complete gap remediation for 28 additional controls
- Select and engage 3PAO (get quotes from 3+)
- Budget appropriately ($300k-$550k initial)
- Allocate internal resources (400-800 hours)
Quick Wins (Implement First):
- SC-28(1) - Data at rest encryption ($0 cost, 8 hours)
- IA-5(1) - Update password policy ($0 cost, 2 hours)
- SI-2(2) - Patch Manager ($100/month, 16 hours)
- AU-4(1) - Cross-region log replication ($200/month, 16 hours)
High Impact:
- IA-2(12) - PIV/CAC support ($5k, 40 hours) - REQUIRED for gov users
- CA-7(3) - Trend analysis ($300/month, 32 hours)
- 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- nist-ai-600-1v0.1.0
- nist-ai-rmfv0.1.0
- nist-csf-20v0.1.0
- nydfsv0.1.0
- okta-inspectorv0.1.0
- onepassword-connectorv0.1.0
- oscalv0.1.0
- pbmmv0.1.0
- pci-dssv0.1.0
- poam-automationv0.1.0
- sg-mas-trmv0.1.0
- singapore-pdpav0.1.0
- slack-inspectorv0.1.0
- snowflake-inspectorv0.1.0
- soc2v0.1.0
- splunk-inspectorv0.1.0
- staterampv0.1.0
- teach-mev0.1.0
- tenable-inspectorv0.1.0
- testssl-inspectorv0.1.0
- trust-centerv0.1.0
- us-ccpav0.1.0
- us-exportv0.1.0
- us-finrav0.1.0