What it does. Automates credential rotation for service accounts across Active Directory, Part of mukul975/Anthropic-Cybersecurity-Skills (817 security skills) (mukul975/Anthropic-Cybersecurity-Skills).

Upstream	mukul975/Anthropic-Cybersecurity-Skills
Skill file	skills/performing-service-account-credential-rotation/SKILL.md
License	Apache-2.0 (skill folder LICENSE)
Author	mukul975
Fetched	2026-09-10

Install

• npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill performing-service-account-credential-rotation, or copy the skill folder into ~/.claude/skills/performing-service-account-credential-rotation/.
• Raw file: curl -sL https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/HEAD/skills/performing-service-account-credential-rotation/SKILL.md

SKILL.md (verbatim)

name: performing-service-account-credential-rotation
description: Automates credential rotation for service accounts across Active Directory,
  cloud platforms, and application databases to eliminate stale secrets and reduce
  compromise risk. Use when rotating or automating rotation of service account passwords,
  API keys, or secrets stored in a vault.
domain: cybersecurity
subdomain: identity-access-management
tags:
- service-accounts
- credential-rotation
- secrets-management
- pam
- automation
- vault
version: '1.0'
author: mahipal
license: Apache-2.0
nist_csf:
- PR.AA-01
- PR.AA-02
- PR.AA-05
- PR.AA-06
mitre_attack:
- T1078
- T1110
- T1556
- T1098
- T1003
mitre_f3:
  version: '1.1'
  tactics:
  - initial-access
  - positioning
  - stealth
  techniques:
  - id: F1006.001
    name: 'Account Takeover: Exposed API Key'
    tactic: initial-access
    source: f3
  - id: F1006.002
    name: 'Account Takeover: Exposed Login Credential'
    tactic: initial-access
    source: f3
  - id: T1110
    name: Brute Force
    tactic: initial-access
    source: attack
  - id: F1005
    name: Account Manipulation
    tactic: positioning
    source: f3
  - id: F1023
    name: Device Fingerprint Spoofing
    tactic: stealth
    source: f3

Performing Service Account Credential Rotation

Overview

Service accounts are non-human identities used by applications, daemons, CI/CD pipelines, and automated processes to authenticate to systems and APIs. These accounts often have elevated privileges and their credentials (passwords, API keys, certificates, tokens) are frequently long-lived and shared across teams, making them prime targets for attackers. Credential rotation is the systematic process of replacing these secrets on a scheduled basis, propagating new credentials to all dependent systems, and verifying service continuity after rotation.

When to Use

• When conducting security assessments that involve performing service account credential rotation
• When following incident response procedures for related security events
• When performing scheduled security testing or auditing activities
• When validating security controls through hands-on testing

Prerequisites

• Inventory of all service accounts across AD, cloud, and applications
• Secrets management platform (HashiCorp Vault, AWS Secrets Manager, Azure Key Vault, or CyberArk)
• Service dependency mapping (which services use which credentials)
• Change management process for rotation windows
• Monitoring for service health post-rotation

Core Concepts

Service Account Types

Type	Platform	Credential	Rotation Method
Active Directory Service Account	Windows/AD	Password	gMSA (automatic) or PAM-managed
AWS IAM User	AWS	Access Key/Secret Key	AWS Secrets Manager rotation Lambda
GCP Service Account	GCP	JSON key file	Key rotation via IAM API
Azure Service Principal	Azure	Client secret/certificate	Key Vault + rotation policy
Database Service Account	SQL/Oracle/Postgres	Password	Vault dynamic secrets
API Key	SaaS applications	API token	Application-specific API

Group Managed Service Accounts (gMSA)

Windows gMSAs provide automatic password management by Active Directory:

• AD automatically rotates the password every 30 days
• Password is 240 bytes, cryptographically random
• Multiple servers can use the same gMSA simultaneously
• No administrator knows or manages the password
• Eliminates manual rotation for Windows services

Rotation Architecture

Secrets Manager / Vault
        │
        ├── Rotation Trigger (schedule or on-demand)
        │
        ├── Generate new credential
        │
        ├── Update credential at source (AD, cloud IAM, database)
        │
        ├── Update credential in all consumers:
        │   ├── Application configuration
        │   ├── CI/CD pipeline secrets
        │   ├── Kubernetes secrets
        │   └── Other dependent services
        │
        ├── Verify service health
        │   ├── Health check endpoints
        │   ├── Authentication test
        │   └── Functional smoke test
        │
        └── Revoke old credential (after grace period)

Workflow

Step 1: Discover and Inventory Service Accounts

Enumerate all service accounts and their dependencies:

# Active Directory: Find all service accounts
Get-ADServiceAccount -Filter * -Properties *
Get-ADUser -Filter {ServicePrincipalName -ne "$null"} -Properties ServicePrincipalName,PasswordLastSet,LastLogonDate

# Find accounts with passwords older than 90 days
$threshold = (Get-Date).AddDays(-90)
Get-ADUser -Filter {PasswordLastSet -lt $threshold -and Enabled -eq $true} -Properties PasswordLastSet,ServicePrincipalName |
    Where-Object {$_.ServicePrincipalName} |
    Select-Object Name, PasswordLastSet, ServicePrincipalName

Step 2: Implement gMSA for Windows Services

# Create KDS Root Key (one-time, domain-wide)
Add-KdsRootKey -EffectiveImmediately

# Create the gMSA account
New-ADServiceAccount -Name "svc-webapp-gmsa" `
    -DNSHostName "svc-webapp-gmsa.corp.example.com" `
    -PrincipalsAllowedToRetrieveManagedPassword "WebServerGroup" `
    -KerberosEncryptionType AES128,AES256

# Install on target server
Install-ADServiceAccount -Identity "svc-webapp-gmsa"

# Test the account
Test-ADServiceAccount -Identity "svc-webapp-gmsa"

# Configure IIS Application Pool to use gMSA
# Set identity to: CORP\svc-webapp-gmsa$

Step 3: AWS Access Key Rotation with Secrets Manager

import boto3
import json

def rotate_iam_access_key(secret_arn, iam_username):
    """Rotate an IAM user's access key via Secrets Manager."""
    iam = boto3.client("iam")
    sm = boto3.client("secretsmanager")

    # Create new access key
    new_key = iam.create_access_key(UserName=iam_username)
    new_access_key = new_key["AccessKey"]["AccessKeyId"]
    new_secret_key = new_key["AccessKey"]["SecretAccessKey"]

    # Store new credentials in Secrets Manager
    sm.put_secret_value(
        SecretId=secret_arn,
        SecretString=json.dumps({
            "accessKeyId": new_access_key,
            "secretAccessKey": new_secret_key,
            "username": iam_username,
        })
    )

    # List old access keys and deactivate them
    keys = iam.list_access_keys(UserName=iam_username)
    for key in keys["AccessKeyMetadata"]:
        if key["AccessKeyId"] != new_access_key and key["Status"] == "Active":
            iam.update_access_key(
                UserName=iam_username,
                AccessKeyId=key["AccessKeyId"],
                Status="Inactive"
            )

    return {"new_key_id": new_access_key, "old_keys_deactivated": True}

Step 4: Database Credential Rotation with Vault

import hvac

def configure_vault_database_rotation(vault_url, vault_token, db_config):
    """Configure HashiCorp Vault for automatic database credential rotation."""
    client = hvac.Client(url=vault_url, token=vault_token)

    # Enable database secrets engine
    client.sys.enable_secrets_engine(
        backend_type="database",
        path="database"
    )

    # Configure database connection
    client.secrets.database.configure(
        name=db_config["name"],
        plugin_name="postgresql-database-plugin",
        connection_url=f"postgresql://{{{{username}}}}:{{{{password}}}}@"
                       f"{db_config['host']}:{db_config['port']}/{db_config['database']}",
        allowed_roles=[db_config["role_name"]],
        username=db_config["admin_user"],
        password=db_config["admin_password"],
    )

    # Create a role for dynamic credentials
    client.secrets.database.create_role(
        name=db_config["role_name"],
        db_name=db_config["name"],
        creation_statements=[
            "CREATE ROLE \"{{name}}\" WITH LOGIN PASSWORD '{{password}}' VALID UNTIL '{{expiration}}';",
            f"GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO \"{{{{name}}}}\";"
        ],
        default_ttl="1h",
        max_ttl="24h",
    )

    return {"status": "configured", "role": db_config["role_name"]}

Step 5: Post-Rotation Verification

After every rotation, verify service continuity:

import requests
import time

def verify_service_health(service_endpoints, max_retries=3, delay=10):
    """Check that services are healthy after credential rotation."""
    results = []
    for endpoint in service_endpoints:
        for attempt in range(max_retries):
            try:
                response = requests.get(
                    endpoint["health_url"],
                    timeout=10,
                    headers=endpoint.get("headers", {})
                )
                healthy = response.status_code == 200
                results.append({
                    "service": endpoint["name"],
                    "status": "healthy" if healthy else f"unhealthy ({response.status_code})",
                    "attempt": attempt + 1,
                })
                if healthy:
                    break
            except requests.RequestException as e:
                results.append({
                    "service": endpoint["name"],
                    "status": f"error: {str(e)}",
                    "attempt": attempt + 1,
                })
            if attempt < max_retries - 1:
                time.sleep(delay)

    return results

Validation Checklist

• Complete inventory of service accounts with dependency mapping
• gMSA implemented for all eligible Windows service accounts
• Cloud access keys rotated via secrets manager (AWS, GCP, Azure)
• Database credentials managed via dynamic secrets (Vault) or rotation policy
• Rotation schedule defined (30-90 days depending on risk level)
• Post-rotation health checks automated
• Alerting configured for rotation failures
• Old credentials revoked after grace period
• Rotation events logged and auditable
• Rollback procedure documented and tested

References

• Google Cloud Service Account Key Rotation
• AWS Secrets Manager Rotation
• Microsoft gMSA Documentation
• HashiCorp Vault Database Secrets Engine

Other files in this skill

• LICENSE
• assets/template.md
• references/api-reference.md
• references/standards.md
• references/workflows.md
• scripts/agent.py
• scripts/process.py

assets/template.md (verbatim)

Service Account Credential Rotation Template

Rotation Campaign

Field	Value
Campaign Date
Rotation Window
Operator
Change Ticket

Service Account Inventory

Account Name	Platform	Type	Last Rotated	Dependent Services	Status
	AD/AWS/GCP/Azure/DB	Password/Key/Cert			Pending/Done/Failed

Rotation Results

Account	New Credential Stored	Source Updated	Consumers Updated	Health Check	Result
	Yes/No	Yes/No	Yes/No	Pass/Fail	Success/Failed

Post-Rotation Verification

• All new credentials stored in secrets vault
• All source systems updated with new credentials
• All consumer applications restarted/reconfigured
• Health checks passing for all dependent services
• Old credentials deactivated/deleted
• Audit log exported and archived
• Operations team notified of completion

references/api-reference.md (verbatim)

API Reference: Service Account Credential Rotation

AWS IAM CLI Key Rotation

Command	Description
aws iam create-access-key --user-name <user>	Create new access key
aws iam list-access-keys --user-name <user>	List existing keys
aws iam update-access-key --access-key-id <id> --status Inactive	Deactivate old key
aws iam delete-access-key --access-key-id <id> --user-name <user>	Delete old key

Azure AD CLI Credential Rotation

Command	Description
az ad app credential reset --id <app-id> --years 1	Generate new client secret
az ad app credential list --id <app-id>	List current credentials
az ad app credential delete --id <app-id> --key-id <key-id>	Remove old credential

HashiCorp Vault Database Secrets Engine

Endpoint	Method	Description
/v1/database/creds/{role}	GET	Generate dynamic database credentials
/v1/database/config/{name}	POST	Configure database connection
/v1/database/roles/{name}	POST	Create dynamic credential role
/v1/sys/leases/revoke	PUT	Revoke a dynamic credential lease

Vault Request Headers

Header	Value
X-Vault-Token	Vault authentication token
Content-Type	application/json

GCP Service Account Key Rotation

Command	Description
gcloud iam service-accounts keys create	Create new key
gcloud iam service-accounts keys list --iam-account <sa>	List keys
gcloud iam service-accounts keys delete <key-id>	Delete old key

Python Libraries

Library	Version	Purpose
subprocess	stdlib	Execute AWS/Azure/GCP CLI commands
requests	>=2.28	HashiCorp Vault HTTP API calls
hvac	>=2.1	HashiCorp Vault Python client
boto3	>=1.26	AWS IAM programmatic key rotation

References

• AWS Secrets Manager Rotation: https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html
• HashiCorp Vault Database Engine: https://developer.hashicorp.com/vault/docs/secrets/databases
• Azure Key Vault Rotation: https://learn.microsoft.com/en-us/azure/key-vault/secrets/tutorial-rotation
• GCP Key Rotation: https://cloud.google.com/iam/docs/key-rotation

references/standards.md (verbatim)

Service Account Credential Rotation - Standards Reference

Compliance Requirements

NIST SP 800-63B - Digital Identity Guidelines

• Authenticator lifecycle management
• Credential rotation for compromised or expired secrets
• Automated mechanisms for credential management preferred

PCI DSS v4.0

• 8.3.9: Passwords/passphrases for application and system accounts changed periodically (at least every 90 days)
• 8.6.1: Interactive use of system and application accounts managed
• 8.6.3: Passwords for application and system accounts protected against misuse

SOC 2 - CC6.1

• Logical access controls restrict access to information assets
• Credentials are managed throughout their lifecycle
• Service account credentials rotated per policy

CIS Controls v8

• 5.2: Use unique passwords
• 5.4: Restrict admin privileges to dedicated accounts
• 5.5: Establish and maintain inventory of service accounts

Rotation Frequency Standards

Account Type	NIST Guideline	PCI DSS	CIS Benchmark	Recommended
Domain Admin	60 days	90 days	90 days	30 days
Service Account (AD)	gMSA auto	90 days	90 days	gMSA (auto 30 days)
Cloud Access Keys	90 days	90 days	90 days	90 days or eliminate
Database Admin	60 days	90 days	90 days	Dynamic secrets (per-session)
API Keys	90 days	N/A	90 days	90 days or short-lived tokens

Technology Standards

gMSA (Group Managed Service Accounts)

• Windows Server 2012+ domain functional level
• KDS Root Key required (one per forest)
• 240-byte cryptographically random passwords
• Automatic rotation every 30 days by default
• Multiple hosts can share same gMSA

PKCS#12 / X.509 Certificate Rotation

• Certificate-based authentication preferred over passwords
• Auto-renewal via ACME protocol or internal CA
• Certificate pinning considerations for service-to-service auth

references/workflows.md (verbatim)

Service Account Credential Rotation - Workflows

Automated Rotation Workflow

Rotation Scheduler (cron/secrets manager)
    │
    ├── Pre-Rotation Checks:
    │   ├── Verify service account exists and is active
    │   ├── Verify all dependent services are healthy
    │   ├── Confirm change window (maintenance window)
    │   └── Notify operations team of pending rotation
    │
    ├── Generate New Credential:
    │   ├── Create new password/key with required complexity
    │   ├── Store new credential in secrets vault
    │   └── Maintain old credential as backup
    │
    ├── Update Source System:
    │   ├── AD: Set-ADAccountPassword
    │   ├── AWS: CreateAccessKey
    │   ├── Azure: Add client secret to service principal
    │   ├── GCP: Create new service account key
    │   └── DB: ALTER USER ... PASSWORD ...
    │
    ├── Propagate to Consumers:
    │   ├── Update application config (env vars, config files)
    │   ├── Update Kubernetes secrets
    │   ├── Update CI/CD pipeline secrets
    │   ├── Restart dependent services if required
    │   └── Wait for propagation
    │
    ├── Post-Rotation Verification:
    │   ├── Health check all dependent services
    │   ├── Test authentication with new credentials
    │   ├── Verify old credential no longer works
    │   └── Log rotation success/failure
    │
    └── Cleanup:
        ├── Deactivate old credential after grace period
        ├── Delete old credential after confirmation
        └── Update rotation audit log

Emergency Rotation Workflow (Credential Compromise)

Credential compromise detected
    │
    ├── IMMEDIATE (within 15 minutes):
    │   ├── Disable compromised credential
    │   ├── Generate new credential
    │   ├── Update source system
    │   └── Notify incident response team
    │
    ├── SHORT-TERM (within 1 hour):
    │   ├── Propagate new credential to all consumers
    │   ├── Verify service health
    │   ├── Review audit logs for unauthorized use
    │   └── Assess blast radius of compromise
    │
    └── FOLLOW-UP (within 24 hours):
        ├── Complete incident report
        ├── Review rotation procedures
        ├── Update dependent service configurations
        └── Rotate any related credentials

gMSA Migration Workflow

Identify service accounts eligible for gMSA migration
    │
    ├── For each eligible service account:
    │   ├── Create gMSA in Active Directory
    │   ├── Add target servers to PrincipalsAllowedToRetrieve
    │   ├── Install gMSA on each target server
    │   ├── Test gMSA retrieval (Test-ADServiceAccount)
    │   │
    │   ├── During maintenance window:
    │   │   ├── Stop the service
    │   │   ├── Change service logon account to gMSA
    │   │   ├── Update file/folder permissions if needed
    │   │   ├── Start the service
    │   │   └── Verify service functionality
    │   │
    │   └── Post-migration:
    │       ├── Disable old service account
    │       ├── Monitor service for 2 weeks
    │       └── Delete old account after confirmation
    │
    └── Update service account inventory

Back to mukul975/Anthropic-Cybersecurity-Skills (817 security skills) or Agent skills.