The setup and configuration of Keeper Rotation is defined by the use case. Keeper supports any cloud or on-prem environment.

Local Network

• Active Directory

• Windows User

• Linux User

• macOS User

• Database - Admin & Users

  • MySQL

  • MariaDB

  • PostgreSQL

  • MongoDB

  • MS SQL Server

  • Oracle

Azure

• Azure AD Domain Services

• Azure App Secrets

• Machine - Windows or Linux User

• Managed Database - Admin & Users

  • Azure SQL User

  • MySQL User or MySQL Flexible User

  • MariaDB User or MariaDB Flexible User

  • PostgreSQL User or PostgreSQL Flexible User

AWS

• AWS AD Directory Users

• EC2 Virtual Machine User - Linux or Windows

• IAM User

• IAM User Access Keys

• AWS Managed Database Admins and Users

  • AWS RDS for MySQL

  • AWS RDS for SQL Server

  • AWS RDS for PostgreSQL

  • AWS RDS for MariaDB

  • AWS RDS for Oracle

SaaS Accounts

• Okta User

• Snowflake User

• REST API

Network Devices

• Cisco IOS XE Users

• Cisco Meraki Users

Overview

In this section, you will learn how to rotate user credentials within the Azure network environment across various target systems. Rotation works on the devices configured and attached to the Azure Active Directory (Azure AD) which can also be your default directory.

KeeperPAM can rotate the password for Azure AD users, service accounts, local admin users, local users, managed services, databases and more.

KeeperPAM Record Types

Configurations for the Azure Active Directory are defined in the PAM Configuration section of Keeper Secrets Manager.

Configurations for the Azure AD joined devices are defined in the PAM Directory, PAM Machine, and PAM Database record types. The credentials and user accounts are defined in PAM User records. The following table shows the supported Azure AD joined devices with Keeper Rotation and their corresponding PAM Record Type:

Prerequisites for Rotation

Prior to rotating user credentials within your Azure environment, you need to make sure you have the following information and configurations in place:

1. All Azure AD joined devices that you want to use with Rotation need to be created and configured within your Azure Active Directory

2. To successfully configure and setup Rotation within your Azure Network, the following values are needed for your PAM Configuration:

1. Make sure all the Azure services or Azure AD joined devices you plan on using for rotation have access to the Azure Active Directory.

2. Create a custom role to allow application to access/perform actions on various Azure resources. For more information see the Azure Environment Setup document.

Setup Steps

At a high level, the following steps are needed to successfully rotate passwords on your Azure network:

1. Create Shared Folders to hold the PAM records involved in rotation

2. Create PAM Machine, PAM Database and PAM Directory records representing each resource

3. Create PAM User records that contain the necessary account credentials for each resource

4. Link the PAM User record to the PAM Resource record.

5. Assign a Secrets Manager Application to all of the shared folders that hold the PAM records

6. Install a Keeper Gateway and add it to the Secrets Manager application

7. Create a PAM Configuration with the Azure environment setting

8. Configure Rotation settings on the PAM User records

Use Cases:

• Azure AD Users

• Azure VM Local Users

• Azure Managed Database

• Azure App Secret

Overview

In this guide, you will learn how to rotate passwords for Azure AD users. In Keeper, the PAM Configuration contains all of the information needed to rotate passwords. The record containing the Azure AD user accounts to be rotated are stored in the PAM User record.

The Keeper Gateway uses Azure APIs to rotate the credentials defined in the PAM User records.

• See the Azure Overview for a high level overview and getting started with Azure

Prerequisites

This guide assumes the following tasks have already taken place:

• Rotation enforcements are configured for your role

• A Keeper Secrets Manager application has been created

• Your Azure environment is configured per our documentation

• Your Keeper Gateway is online

1. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for Azure.

Prior to setting up the PAM Configuration, make sure that:

• A Keeper Secrets Manager application has been created

• A Keeper Rotation gateway is already installed, running, and is provisioned in the Keeper Secrets Manager application you created.

• We recommend installing the Keeper Gateway service in a machine within the Azure environment in order to rotate other types of targets.

In the left menu of the vault, select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration". The following table lists all the required fields that needs to be filled on the PAM Configuration Record with your information:

2. Set up one or more PAM User Records

Keeper Rotation uses the Azure Graph API to rotate the PAM User records in your Azure environment. The PAM User records need to be in a shared folder that is shared to the KSM application created in the pre-requisites.

The following table lists all the required fields that needs to be filled on the PAM User record with your information:

3. Configure Rotation on the PAM User Records

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select "IAM User" for the rotation method, since this uses Azure APIs.

• The "Rotation Settings" should select the PAM Configuration setup previously.

• Select the desired schedule and password complexity.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Overview

In this guide, you'll learn how to rotate Azure Virtual Machine local and remote user accounts within the Azure environment using KeeperPAM.

• See the Azure Overview for a high level overview and getting started with Azure

Prerequisites

• Rotation enforcements are configured for your role

• A Keeper Secrets Manager application has been created

• Your Azure environment is configured per our documentation

• A Keeper Rotation gateway is already installed

• The Gateway can communicate to the target Windows machine using WinRM or SSH

• PowerShell is available on all Windows machines and bash on all Linux targets

1. Set up PAM Machine Records

Keeper can rotate any local user account on either the Gateway machine or any other machine on the network. A PAM Machine record should be created for every machine. This PAM Machine record will be associated to a linked administrative credential that has the rights to change passwords for users on the machine.

Once a PAM Machine record is created for every machine, a PAM User record needs to be created for each user account that will be rotated.

The following table lists all the required fields that needs to be filled on the PAM Machine records.

2. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

Make sure the following items are completed first:

• A Keeper Secrets Manager application has been created

• A Keeper Rotation gateway is already installed, running, and is provisioned in the Keeper Secrets Manager application you created.

• PAM Machine records have been created for each target machine

If you are creating a new PAM Configuration, login to the Keeper Vault and select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration". The following table lists all the required fields that needs to be filled on the PAM Configuration.

3. Set up PAM User records

Keeper Rotation will use the credentials linked from the PAM Machine record to rotate the credentials of accounts referenced by the PAM User records.

The following table lists all the required fields that need to be filled on the PAM User record:

4. Configure Rotation on the PAM User records

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select the desired schedule and password complexity.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• The "Resource Credential" field should select the PAM Machine admin credential specific to this user's machine.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Helpful Resources

• Setting up WinRM on your Azure VM

Service Management

Keeper can automatically update the Windows service account "log on as" credentials for any Windows services running as the PAM User, and restart the service. Keeper will also update the credential of any scheduled task running as that user on the target machine.

To learn more and set up this capability, see the Service Management page.

In this section, you will learn how to rotate DB User or Admin credentials on the following Azure Managed Databases:

• Azure SQL

• Azure MySQL

• Azure MariaDB

• Azure PostgreSQL

Overview

In this guide, you'll learn how to rotate passwords for Azure SQL Database Users and Admin accounts on your Azure environment using Keeper Rotation. Azure SQL is an Azure managed resource where the SQL Admin Credentials are defined in the PAM Database record type and the configurations of the SQL Users are defined in the PAM User record type.

For Azure Managed SQL database, the Azure SDK will be used to rotate the password of Database Admin Accounts. To rotate the passwords of Regular Database Users, Keeper connects to the DB instance with the linked admin credentials and executes the necessary SQL statements to change the password.

• See the Azure Overview for a high level overview and getting started with Azure

Prerequisites

This guide assumes the following tasks have already taken place:

• Rotation enforcements are configured for your role

• A Keeper Secrets Manager application has been created

• Your Azure environment is configured per our documentation

• Your Keeper Gateway is online

• The Keeper Gateway is able to communicate with your Azure SQL Server Database

• If the Gateway is installed on a Linux or macOS server, install the Microsoft ODBC driver

• Your Azure environment is configured per our documentation

1. Set up a PAM Database Record

The PAM Database record links to admin credentials and contains the necessary configurations to connect to the SQL Server on Azure. Keeper Rotation will use these provided configurations to rotate passwords of regular database user accounts in the Azure SQL Server instance. These provided admin credentials need to also have sufficient database permissions to successfully change the credentials of the database user accounts.

The following table lists all the required fields on the PAM Database Record:

Note: Adding Provider Group, Provider Region, and Database ID will enable managing the PAM Database Record through the Azure SDK.

This PAM Database Record with the linked admin credential needs to be in a shared folder that is shared to the KSM application created in the pre-requisites. Only the KSM application needs access to this privileged account, it does not need to be shared with any users.

2. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

If you are creating a new PAM Configuration, login to the Keeper Vault and select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration". The following table lists all the required fields on the PAM Configuration Record:

For more details on all the configurable fields in the PAM Configuration record, visit this page.

3. Set up one or more PAM User records

Keeper Rotation will use the linked credentials in the PAM Database record to rotate the PAM User records on your Azure environment. The PAM User credential needs to be in a shared folder that is shared to the KSM application created in the prerequisites.

The following table lists all the required fields on the PAM User record:

4. Configure Rotation on the PAM User records

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select the desired schedule and password complexity.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• The "Resource Credential" field should select the PAM Database credential setup from Step 1.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Overview

In this guide, you'll learn how to rotate passwords for Azure MySQL Database Users and Admin accounts on your Azure environment using Keeper Rotation. Azure MySQL is an Azure managed resource where the MySQL Admin Credentials are defined in the PAM Database record type and the configurations of the MySQL Users are defined in the PAM User record type.

For Azure Managed MySQL database, the Azure SDK will be used to rotate the password of Database Admin Accounts. To rotate the passwords of Regular Database Users, Keeper connects to the DB instance with the provided admin credentials and executes the necessary SQL statements to change the password.

• See the Azure Overview for a high level overview and getting started with Azure

Prerequisites

This guide assumes the following tasks have already taken place:

• Rotation enforcements are configured for your role

• A Keeper Secrets Manager application has been created

• Your Azure environment is configured per our documentation

• Your Keeper Gateway is online

• Your Keeper Gateway is able to communicate with the Azure MySQL Server Database

1. Set up a PAM Database Record

The PAM Database record links to the admin credentials and necessary configurations to connect to the MySQL Server on Azure. Keeper Rotation will use these provided configurations to rotate passwords of regular database user accounts in the Azure MySQL Server instance. These provided admin credentials need to also have sufficient database permissions to successfully change the credentials of the database user accounts.

The following table lists all the required fields on the PAM Database Record:

Note: Adding Provider Group, Provider Region, and Database ID will enable managing the PAM Database Record through the Azure SDK.

This PAM Database Record with the admin credential needs to be in a shared folder that is shared to the KSM application created in the pre-requisites. Only the KSM application needs access to this privileged account, it does not need to be shared with any users.

2. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

If you are creating a new PAM Configuration, login to the Keeper Vault and select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration". The following table lists all the required fields on the PAM Configuration Record:

For more details on all the configurable fields in the PAM Configuration record, visit this page.

3. Set up one or more PAM User records

Keeper Rotation will use the linked credentials in the PAM Database record to rotate the PAM User records on your Azure environment. The PAM User credential needs to be in a shared folder that is shared to the KSM application created in the prerequisites.

The following table lists all the required fields on the PAM User record:

4. Configure Rotation on the PAM User records

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select the desired schedule and password complexity.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• The "Resource Credential" field should select the PAM Database credential setup from Step 1.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Overview

In this guide, you'll learn how to rotate passwords for Azure MariaDB Users and Admin accounts on your Azure environment using KeeperPAM. Azure MariaDB is an Azure managed resource where the MariaDB Admin Credentials are defined in the PAM Database record type and the configurations of the MariaDB Users are defined in the PAM User record type.

For Azure Managed MariaDB database, the Azure SDK will be used to rotate the password of Database Admin Accounts. To rotate the passwords of Regular Database Users, Keeper connects to the DB instance with the provided admin credentials and executes the necessary SQL statements to change the password.

• See the Azure Overview for a high level overview and getting started with Azure

Prerequisites

This guide assumes the following tasks have already taken place:

• Rotation enforcements are configured for your role

• A Keeper Secrets Manager application has been created

• Your Azure environment is configured per our documentation

• Your Keeper Gateway is online

• Your Keeper Gateway is able to communicate with the Azure Managed MariaDB database

1. Set up a PAM Database Record

The PAM Database record links to the admin credentials and necessary configurations to connect to the MariaDB server on Azure. Keeper Rotation will use these provided configurations to rotate passwords of regular database user accounts in the Azure MariaDB Server instance. These provided admin credentials need to also have sufficient database permissions to successfully change the credentials of the database user accounts.

The following table lists all the required fields on the PAM Database Record:

Note: Adding Provider Group, Provider Region, and Database ID will enable managing the PAM Database Record through the Azure SDK.

This PAM Database Record with the admin credential needs to be in a shared folder that is shared to the KSM application created in the pre-requisites. Only the KSM application needs access to this privileged account, it does not need to be shared with any users.

2. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

If you are creating a new PAM Configuration, login to the Keeper Vault and select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration". The following table lists all the required fields on the PAM Configuration Record:

For more details on all the configurable fields in the PAM Configuration record, visit this page.

3. Set up one or more PAM User records

Keeper Rotation will use the linked credentials in the PAM Database record to rotate the PAM User records on your Azure environment. The PAM User credential needs to be in a shared folder that is shared to the KSM application created in the prerequisites.

The following table lists all the required fields on the PAM User record:

4. Configure Rotation on the PAM User records

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select the desired schedule and password complexity.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• The "Resource Credential" field should select the PAM Database credential setup from Step 1.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Overview

In this guide, you'll learn how to rotate passwords for Azure PostgreSQL Database Users and Admin accounts on your Azure environment using KeeperPAM. Azure PostgreSQL is an Azure managed resource where the PostgreSQL Admin Credentials are defined in the PAM Database record type and the configurations of the PostgreSQL Users are defined in the PAM User record type.

For Azure Managed PostgreSQL database, the Azure SDK will be used to rotate the password of Database Admin Accounts. To rotate the passwords of Regular Database Users, Keeper connects to the DB instance with the provided admin credentials and executes the necessary SQL statements to change the password.

• See the Azure Overview for a high level overview and getting started with Azure

Prerequisites

This guide assumes the following tasks have already taken place:

• Rotation enforcements are configured for your role

• A Keeper Secrets Manager application has been created

• Your Azure environment is configured per our documentation

• Your Keeper Gateway is online

• Your Keeper Gateway is able to communicate with the Azure Managed PostgreSQL database

1. Set up a PAM Database Record

The PAM Database record links to the admin credentials and necessary configurations to connect to the PostgreSQL Server on Azure. Keeper Rotation will use these provided configurations to rotate passwords of regular database user accounts in the Azure PostgreSQL Server instance. These provided admin credentials need to also have sufficient database permissions to successfully change the credentials of the database user accounts.

The following table lists all the required fields on the PAM Database Record:

Note: Adding Provider Group, Provider Region, and Database ID will enable managing the PAM Database Record through the Azure SDK.

This PAM Database Record with the admin credential needs to be in a shared folder that is shared to the KSM application created in the pre-requisites. Only the KSM application needs access to this privileged account, it does not need to be shared with any users.

2. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment..

If you are creating a new PAM Configuration, login to the Keeper Vault and select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration". The following table lists all the required fields on the PAM Configuration Record:

For more details on all the configurable fields in the PAM Configuration record, visit this page.

3. Set up one or more PAM User records

Keeper Rotation will use the linked credentials in the PAM Database record to rotate the PAM User records on your Azure environment. The PAM User credential needs to be in a shared folder that is shared to the KSM application created in the prerequisites.

The following table lists all the required fields on the PAM User record:

4. Configure Rotation on the PAM User records

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select the desired schedule and password complexity.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• The "Resource Credential" field should select the PAM Database credential setup from Step 1.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Overview

This documentation explains how to rotate Azure application secrets using KeeperPAM's rotation option called "Run PAM scripts only". This is a setting in the PAM User rotation settings which tells the Gateway to skip the primary rotation method and directly execute the post-rotation script attached to the PAM User record in the vault.

This guide includes prerequisites, step-by-step instructions, and a Python script example. The script ensures secure application secrets rotation, including deletion of previous application secrets, and stores the new application secret in Keeper. This new secret is automatically available to all already allowed KSM applications and users.

• See the Azure Overview for a high level overview and getting started with Azure

Prerequisites

This guide assumes the following tasks have already taken place:

• Rotation enforcements are configured for your role

• A Keeper Secrets Manager application has been created

• Your Azure environment is configured per our documentation

• The gateway host will need to have a supported Python version installed with the 2 dependencies below:

pip3 install keeper_secrets_manager_core
pip3 install azure.identity

Rotation Script Logic Flow

1. Admin Credentials Retrieval

The script retrieve admin credentials in three ways:

1. Record directly attached to the post rotation script.

2. The access key provided to the Azure PAM config selected for the rotation. This will be used if no access key is found in the record(s) attached (method 1 above) to the post rotation script.

2. Secret Rotation Logic

The script will:

1. Retrieve an admin application secret either from an attached record to the PAM Script or from the PAM Config.

2. Get a Microsoft Graph access token using the admin application secret found at the step above.

3. Create a new client secret on the Azure application defined in the PAM User record.

4. Delete all other existing secrets for the defined Azure application. Only the one generated at the step above will be kept.

5. Update the Keeper PAM User record with the new secret, and secret ID.

PAM User Record - Fields Requirements

You need to create a PAM User record where the rotation will be configured later on. The fields below need to be created.

Fields required:

Custom fields required:

application_object_id

client_secret_id

client_secret

expires

Private Key Type

rsa-ssh

Setting Up the Rotation in the Keeper Vault

Using PAM Config Admin Secret

The script require an admin application secret to authenticate against Azure and rotate another application's secret. Here we will be using the admin app secret provided in the Azure PAM Configuration.

Configuration From the Keeper Vault:

1. Create a shared folder in the vault

2. Create a PAM User record in the shared folder with the fields and custom fields described above.

1. In the Secret Manager tab of the Keeper vault, create a new application for the gateway if there is no gateway yet.

2. Make sure the Application has edit permissions on the shared folder created above.

3. Provision the gateway (gateway tab after selecting the application) on a Linux box. Simply run the install command provided by the Keeper vault and make sure Python and the dependencies listed above are installed.

4. In the Secret Manager tab of the Keeper vault, go to the PAM Configurations tab. Create a new PAM configuration if needed.

5. Under Environment, please select “Azure”, select the Gateway, select the shared folder, provide the “Entra ID” name (arbitrary name of your Entra ID environment), the admin application “Client ID” (Overview tab of the admin application in the Azure portal), “Client Secret” (Certificates & secrets tab of the admin application in the Azure portal), "Subscription ID" and "Tenant ID".

1. Edit the PAM User record previously described in this documentation:

   • Password Rotation Settings: select your desired schedule and the PAM configuration created above.

   • Select "Run PAM Scripts only" as the Rotation method.

   • Add PAM Script to the record: select the provided file below and make sure to specify the script command:

Copy

python3

Using Another Rotation Record Admin Secret

It is possible to also rotate the application secret of the admin Azure application. To do this, you will need to store you admin Azure app secret in another Keeper PAM User record.

Admin App Secret Record Requirements

The PAM user record will need all fields as described in the documentation above, along with the additional fields below:

Custom fields required:

Custom Field Label

Field Type

Description

Copy

tenant_id

Text

Enter your Azure Tenant ID.

Copy

application_client_id

Text

Enter your admin application client ID. This is available in the Overview tab of the admin application in the Azure portal > App registrations.

Instead of creating the PAM User record manually using the documentation above and the extra fields above, you could also import the csv file below. It will create a template record you can amend and duplicate as needed.

Importing the file will generate a Login record type: make sure to convert it to PAM User.

338B

PAM User Template AdminAzureAppSecretRotation.csv

Configuration From the Keeper Vault:

1. Create a shared folder in the vault

2. Create a PAM User record in the shared folder with the fields and custom fields described above.

1. In the Secret Manager tab of the Keeper vault, create a new application for the gateway if there is no gateway yet.

2. Make sure the Application has edit permissions on the shared folder created above.

3. Provision the gateway (gateway tab after selecting the application) on a Linux box. Simply run the install command provided by the Keeper vault and make sure Python and the dependencies listed above are installed.

4. In the Secret Manager tab of the Keeper vault, go to the PAM Configurations tab. Create a new PAM configuration if needed.

5. Under Environment, please select “Local Network”, select the Gateway and the shared folder.

1. Edit the target app PAM User record:

   • Password Rotation Settings: select your desired schedule and the PAM configuration created above.

   • Add PAM Script to the record:

     1. Select the provided Python file below.

     2. Rotation Credential: select the admin app PAM User record.

     3. Specify the script command:

Copy

python3

Python Script

import logging
import requests
import sys
import base64
import json
from azure.identity import ClientSecretCredential
from datetime import datetime, timedelta, timezone
from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage

# sys.stdin is not an array, it cannot be subscripted (i.e., sys.stdin[0])
for base64_params in sys.stdin:
    # Retrieve params from the gateway
    params = json.loads(base64.b64decode(base64_params).decode('utf-8'))
    break

# Retrieve records attached to the post-rotation script in Keeper
records = json.loads(base64.b64decode(params.get('records')).decode('utf-8'))

# Initiate Keeper Secrets Manager SDK using the gateway configuration
secrets_manager = SecretsManager(config=FileKeyValueStorage('/etc/keeper-gateway/gateway-config.json'))

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

GRAPH_API_URL = "https://graph.microsoft.com/v1.0"

# Function to get Microsoft Graph access token using ClientSecretCredential
def get_access_token(tenant_id, client_id, client_secret):
    try:
        credential = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)
        token = credential.get_token("https://graph.microsoft.com/.default")
        logger.info("Authentication successful.")
        return token.token
    except Exception as e:
        logger.error(f"Authentication failed: {e}")
        raise

# Function to create a new client secret and return its ID and secret text
def create_client_secret(access_token, target_app_id, secret_expiry_days=365):
    try:
        # Set expiry time for the secret using timezone-aware datetime
        expiry_time = (datetime.now(timezone.utc) + timedelta(days=secret_expiry_days)).isoformat()

        # API request body to create a new client secret
        body = {
            "passwordCredential": {
                "displayName": "Client Secret Rotated by Keeper",
                "endDateTime": expiry_time
            }
        }

        headers = {
            "Authorization": f"Bearer {access_token}",
            "Content-Type": "application/json"
        }

        response = requests.post(f"{GRAPH_API_URL}/applications/{target_app_id}/addPassword", json=body, headers=headers)
        
        if response.status_code == 200:
            response_json = response.json()
            new_client_secret = response_json['secretText']
            secret_id = response_json['keyId']  # Fetch the ID of the new secret

            # Log both the new secret and its ID
            logger.info(f"New client secret created for Application {target_app_id}. Secret ID: {secret_id}.")
            return secret_id, new_client_secret, expiry_time
        else:
            logger.error(f"Failed to create client secret: {response.status_code}, {response.text}")
            raise Exception(f"Failed to create client secret: {response.status_code}")
    except Exception as e:
        logger.error(f"An error occurred: {e}")
        raise

# Function to retrieve existing client secrets
def get_existing_client_secrets(access_token, target_app_id):
    try:
        headers = {
            "Authorization": f"Bearer {access_token}"
        }

        response = requests.get(f"{GRAPH_API_URL}/applications/{target_app_id}", headers=headers)
        if response.status_code == 200:
            app = response.json()
            logger.info(f"Retrieved existing client secrets for Application {target_app_id}.")
            return app.get('passwordCredentials', [])
        else:
            logger.error(f"Failed to retrieve client secrets: {response.status_code}, {response.text}")
            raise Exception(f"Failed to retrieve client secrets: {response.status_code}")
    except Exception as e:
        logger.error(f"An error occurred: {e}")
        raise

# Function to delete old client secrets, excluding the newly created one
def delete_old_secrets(access_token, target_app_id, new_client_secret_id):
    try:
        headers = {
            "Authorization": f"Bearer {access_token}",
            "Content-Type": "application/json"
        }

        existing_secrets = get_existing_client_secrets(access_token, target_app_id)
        
        # Iterate through all secrets and delete the ones that are not the newly created secret
        for secret in existing_secrets:
            if secret['keyId'] != new_client_secret_id:
                body = {
                    "keyId": secret['keyId']
                }
                response = requests.post(f"{GRAPH_API_URL}/applications/{target_app_id}/removePassword", json=body, headers=headers)

                if response.status_code == 204:
                    logger.info(f"Deleted secret with ID: {secret['keyId']} for Application {target_app_id}.")
                else:
                    logger.error(f"Failed to delete secret: {response.status_code}, {response.text}")
                    raise Exception(f"Failed to delete secret: {response.status_code}")
    except Exception as e:
        logger.error(f"An error occurred: {e}")
        raise

# Main function
def rotate_client_secret(tenant_id, client_id, client_secret, target_app_id, secret_expiry_days=365, delete_old_secrets_flag=False):
    try:
        # Step 1: Get access token
        access_token = get_access_token(tenant_id, client_id, client_secret)
        
        # Step 2: Create a new client secret and get its ID
        new_client_secret_id, new_client_secret, expiry_time = create_client_secret(access_token, target_app_id, secret_expiry_days)
        if not new_client_secret:
            logger.error("Failed to create a new client secret. Exiting.")
            return None, None, None  # Prevent further execution if secret creation failed
        
        logger.info(f"New client secret id: {new_client_secret_id}. Expiration date: {expiry_time}")
        
        # Step 3: Optionally delete old secrets, but exclude the newly created one
        if delete_old_secrets_flag:
            delete_old_secrets(access_token, target_app_id, new_client_secret_id)

        return new_client_secret_id, new_client_secret, expiry_time
    except Exception as e:
        logger.error(f"An error occurred during the secret rotation process: {e}")
        return None, None, None  # Return None in case of an error

# Inputs from the gateway and full PAM user query using KSM
pam_user_to_update = secrets_manager.get_secrets([params.get('userRecordUid')])[0]

# Retrieve app object id to rotate
try:
    target_app_id = pam_user_to_update.custom_field('application_object_id', single=True)
except Exception as e:
    raise RuntimeError(f"No app object id found, the script will exit after this error: {e}")

# Retrieve admin user account access key
admin_cred_provided = False
for record in records:
    if "application_client_id" in record:
        client_id = record["application_client_id"]
        client_secret = record["client_secret"]
        tenant_id = record["tenant_id"]
        admin_cred_provided = True
        logger.info(f"Admin creds provided. Using secret_id {client_id}, from attached record UID {record['uid']}.")
        break
    elif "clientId" in record:
        client_id = record["clientId"]
        client_secret = record["clientSecret"]
        tenant_id = record["tenantId"]
        admin_cred_provided = True
        logger.info(f"Admin creds provided. Using secret_id {client_id}, from attached PAM Config record UID {record['uid']}.")
        break

# If there is no app key provided to an attached record, then use the PAM config.
if admin_cred_provided == False:
    try:
        pam_config = secrets_manager.get_secrets([params.get('providerRecordUid')])[0]
        client_id = pam_config.field('clientId', single=True)
        client_secret = pam_config.field('clientSecret', single=True)
        tenant_id = pam_config.field('tenantId', single=True)
        admin_cred_provided = True
        logger.info(f"Using PAM config creds. Using secret_id {client_id}, from PAM Config UID.")
    except Exception as e:
        logger.error(f"Error retrieving admin creds from PAM config: {e}")

# Exit if no credentials were provided
if not admin_cred_provided:
    raise RuntimeError("No admin creds provided. The script will exit.")

# Rotate client secret and handle success/failure
new_client_secret_id, new_client_secret, expiry_time = rotate_client_secret(
    tenant_id, client_id, client_secret, target_app_id, secret_expiry_days=365, delete_old_secrets_flag=True
)

if new_client_secret_id and new_client_secret:
    logger.info("\nRotation Result:")
    logger.info(f"New secret id: {new_client_secret_id}")

    # Update the PAM User record in Keeper
    try:
        pam_user_to_update.custom_field('client_secret_id', new_client_secret_id)
        pam_user_to_update.custom_field('client_secret', new_client_secret)
        pam_user_to_update.custom_field('expires', expiry_time)
        secrets_manager.save(pam_user_to_update)
    except Exception as e:
        logger.error(f"Error while updating PAM User record in Keeper: {e}")

Overview

In this section, you will learn how to rotate user credentials within the AWS Cloud environment across various target systems and services.

KeeperPAM Record Types

Configurations for your AWS environment are defined in the PAM Configuration section of Keeper Secrets Manager. Keeper will use the inherited EC2 instance role where the Gateway is installed to authenticate with the AWS system and perform rotation. If instance roles are not defined, the AWS Access Key ID and Secret Key can be stored in the PAM Configuration record to authenticate and perform rotations.

Configurations for managed resources like EC2, RDS, and Directory Services are defined in the PAM Machine, PAM Database, and PAM Directory record types. The following table shows the supported AWS managed resources with KeeperPAM and their corresponding PAM Record Type:

Configurations for directory users or IAM users are defined in the PAM User record type.

Prerequisites

To successfully rotate IAM User accounts or EC2 local user accounts, the Keeper Gateway needs to have the necessary AWS role policies with the permissions for performing the password rotation.

• See the AWS environment setup guide for more information.

If you are not using EC2 instance role policies, the following values are needed in the PAM Configuration:

The Keeper Gateway will always first attempt to use the EC2 instance role to authenticate and perform the rotation. If this fails or is not available on the machine, Keeper will use the Access Key ID and Secret Access Key stored in the PAM Configuration.

Setup Steps

At a high level, the following steps are needed to successfully rotate passwords on your Azure network:

1. Create Shared Folders to hold the PAM records involved in rotation

2. Create PAM Machine, PAM Database and PAM Directory records representing each resource

3. Create PAM User records that contain the necessary account credentials for each resource

4. Link the PAM User record to the PAM Resource record.

5. Assign a Secrets Manager Application to all of the shared folders that hold the PAM records

6. Install a Keeper Gateway and add it to the Secrets Manager application

7. Create a PAM Configuration with the AWS environment setting

8. Configure Rotation settings on the PAM User records

Use Cases

• IAM User Password

• Managed Microsoft AD User

• EC2 Instance local user

• IAM User Access Key

• Managed Database

Overview

In this guide, you will learn how to rotate passwords for AWS IAM users. In Keeper, the PAM Configuration contains all of the information needed to rotate passwords. The record containing the AWS IAM user accounts to be rotated are stored in the PAM User record.

Prerequisites

This guide assumes the following tasks have already taken place:

• Keeper Secrets Manager is enabled for your role

• Keeper Rotation is enabled for your role

• A Keeper Secrets Manager application has been created

• A Keeper Rotation gateway is already installed and running

• Your AWS environment is configured per our documentation

The Keeper Gateway uses AWS APIs to rotate the credentials defined in the PAM User records.

1. Create Shared Folder

In this folder, you’ll create records for the AWS IAM accounts that you’ll rotate. You will create a PAM User record for each user that will be rotated.

2. Create PAM User Record(s)

Keeper Rotation uses the AWS API to rotate the PAM User records in your AWS environment. The PAM User records need to be in a shared folder that is shared to the KSM application created in the prerequisites.

The following table lists all the required fields on the PAM User record:

3. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

In the left menu of the vault, select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration". The following table lists all the required fields on the PAM Configuration Record:

For more details on all the configurable fields in the PAM Configuration record, visit this page.

4. Configure Rotation on the PAM User Records

Select the PAM User record(s) from Step 2, edit the record and open the "Password Rotation Settings".

• Select "IAM User" as the rotation method, since this uses AWS APIs.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• Select the desired schedule and password complexity.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Note: The user must have AWS Console access and at minimum have a temporary password set in the AWS Console before the password can be rotated.

Overview

In this guide, you will learn how to rotate Admin and User Accounts of an AWS Managed Microsoft AD service using Keeper Rotation. The Active Directory Service is an AWS managed resource where the Directory Service admin credentials are linked to the PAM Directory record type and the configurations of the AD Users are defined in the PAM User record type.

For Amazon Managed Active Directory Services, the AWS SDK will be used to rotate the password of Directory Admins. User Account passwords will be rotated using LDAP and, in order to successfully rotate, server-side LDAPS must be configured and the Directory Admin, defined in the PAM Directory record type, must be using a SSL Connection.

Prerequisites

This guide assumes the following tasks have already taken place:

• Keeper Secrets Manager is enabled for your role

• Keeper Rotation is enabled for your role

• A Keeper Secrets Manager application has been created

• A Keeper Rotation gateway is already installed, running, and is able to communicate with your AWS Directory Services

• Your AWS environment is configured per our documentation

1. Set up a PAM Directory Record

Keeper Rotation will use the linked admin credentials of your AWS Managed Directory Service to rotate passwords of Domain Service's directory accounts. These admin credentials can also be used to rotate the passwords of the Directory admin.

The following table lists all the required fields on the PAM Directory Record:

Note: Adding Provider Region and Directory ID will enable managing the PAM Directory Record through the AWS SDK, which is preferred.

This PAM Directory Record with the admin credential needs to be in a shared folder that is shared to the KSM application created in the pre-requisites. Only the KSM application needs access to this privileged account, it does not need to be shared with any users.

2. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

If you are creating a new PAM Configuration, login to the Keeper Vault and select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration". The following table lists all the required fields on the PAM Configuration Record:

For more details on all the configurable fields in the PAM Configuration record, visit this page.

3. Set up one or more PAM User Records

Keeper Rotation will use the credentials in the PAM Directory record to rotate the PAM User records on your AWS environment. The PAM User credential needs to be in a shared folder that is shared to the KSM application created in the prerequisites.

The following table lists all the required fields on the PAM User record:

4. Configure Rotation on the PAM User records

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select the desired schedule and password complexity.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• The "Resource Credential" field should select the PAM Directory credential setup from Step 1.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Troubleshooting

Getting the Distinguished Names of AWS Managed Directory Service Users

The following windows command can be used to get the distinguished name of the Directory user:

Get-ADUser -Identity "username" | Select-Object -ExpandProperty DistinguishedName

If the command does not exist, you need to import the appropriate module with:

Import-Module ActiveDirectory

In this guide, you will learn how to rotate AWS EC2 Virtual Machine (VM) Accounts on your AWS Environment using Keeper Rotation. The EC2 VM is an AWS managed resource where the EC2 VM Admin Credentials are linked to the PAM Machine record and the identity of the EC2 VM Users are defined in the PAM User record type.

For EC2 VM Accounts, normal operating system commands are used to change the password. Keeper will connect to the target machine and send command-line commands to change the password.

Prerequisites

This guide assumes the following tasks have already taken place:

• Keeper Secrets Manager is enabled for your role

• Keeper Rotation is enabled for your role

• A Keeper Secrets Manager application has been created

• A Keeper Rotation gateway is already installed, running, and is able to communicate via SSH or WinRM with your target AWS Virtual Machine(s).

• Your AWS environment is configured per our documentation

1. Set up PAM Machine Records

Keeper can rotate any local user account on either the Gateway machine or any other machine on the network. A PAM Machine record should be created for every machine. This PAM Machine record should link to an administrative credential that has the rights to change passwords for users on the machine.

Once a PAM Machine record is created for every machine, a PAM User record needs to be created for each local user account that will be rotated.

Keeper will use the referenced admin credential to rotate the password or SSH key of AWS Virtual Machine users in your AWS environment. These admin credentials need to have the sufficient permissions in order to successfully change the credentials of these user accounts.

If you are running a rotation on a PAM Machine record which also happens to be the same machine running the Keeper Gateway, Keeper will attempt to rotate the password or SSH key for the account using the keeper-gw user. Assuming that keeper-gw has sudoers privilege, it will be able to perform rotations on the local Gateway machine.

The following table lists all the required fields on the PAM Machine record:

This PAM Machine Record with the linked admin credential needs to be in a shared folder that is shared to the KSM application created in the prerequisites. Only the KSM application needs access to this privileged account, it does not need to be shared with any users.

2. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

Make sure the following items are completed:

• A Keeper Secrets Manager application has been created

• A Keeper Rotation gateway is already installed, running, and is provisioned in the Keeper Secrets Manager application you created.

• PAM Machine records have been created for each target machine

If you are creating a new PAM Configuration, login to the Keeper Vault and select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration". The following table lists all the required fields that needs to be filled on the PAM Configuration.

For more details on all the configurable fields in the PAM Configuration record, visit this page.

3. Set up PAM User Records

Keeper will use the credentials linked from the PAM Machine record to rotate the PAM User records in your AWS environment. The PAM User credential needs to be in a shared folder that is shared to the KSM application created in the prerequisites.

The following table lists all the required fields that need to be filled on the PAM User record:

4. Configure Rotation on the Record - AWS VM User

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select the desired schedule and password complexity.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• The "Resource Credential" field should select the PAM Machine credential setup from Step 1.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

SSH Key Rotation Notes

When rotating the private PEM Key credential on a target machine or user, Keeper will update the authorized_keys file on the machine with the new public key. The first time that a rotation occurs, the old public key is left intact in order to prevent system lockout. The second public key added to the file contains a comment that serves as an identifier for future rotations. For example:

[ec2-user@host .ssh]$ cat authorized_keys
ssh-rsa AAAAB3NzaC1...11xZrfOxYXG6RV84mCZ3uldesEyV/ghLxAb7Fcz awsdemo
ssh-rsa AAAAB3NzaC...un+frl9Q== keeper-security-ec2user

By default, Keeper will not remove other keys from the .ssh/authorized_keys file since some providers will place in their own keys in order to control the virtual machine (ie Google Cloud Provider).

If the first rotation is successful, you can optionally delete the old public key entry in the authorized_keys file. On subsequent rotations, Keeper will update the line which contains the "keeper-security-xxx" comment.

Rotation will also create backup of the prior .ssh/authorized_keys inside of the .ssh directory.

For private key rotation, the new private key will be same algorithm and key size (bits) as the current private key. For example, if the current private key is ecdsa-sha2-nistp256 the new private key will be ecdsa-sha2-nistp256. This can be overridden by adding a custom text field, with the label Private Key Type , and setting the value to one support algorithms:

• ssh-rsa - 4096 bits

• ecdsa-sha2-nistp256 - ECDSA, 256 bits

• ecdsa-sha2-nistp384 - ECDSA, 384 bits

• ecdsa-sha2-nistp521 - ECDSA, 521 bits

• ssh-ed2551

.This custom field can also be used if the current private key's algorithm cannot be detected.

To prevent private key rotation, a custom text field can be added to the PAM User record with the label Private Key Rotate. If the value of the field is TRUE, or the field doesn't exists, the private key will be rotated if it exists. If the value is FALSE, the private key will not be rotated.

For Linux user rotations, password-encrypted PEM files are not currently supported.

Overview

This documentation explains how to rotate AWS IAM user access keys using KeeperPAM's rotation option called "Run PAM scripts only". This is a setting in the PAM User rotation settings which tells the Gateway to skip the primary rotation method and directly execute the post-rotation script attached to the PAM User record in the vault.

This guide includes prerequisites, step-by-step instructions, and a Python script example. This provided script supports both provided admin credentials (AWS Access key for an admin account) and EC2 instance role authentication. The script ensures secure access key rotation, including deletion of previous user keys. The new key is stored in the Keeper record after rotation is complete.

Prerequisites

1. KSM role: Ensure that the Keeper user has a role providing access to Keeper Secrets Manager, and Keeper Secrets Manager rotations.

2. A Linux instance to run the Keeper Gateway: The Gateway can be deployed in an EC2 instance, any private Cloud or on-prem. This script is capable of leveraging EC2 Instance Roles Authentication to perform the Access Key rotation if the Gateway runs in an EC2 instance. If the gateway runs somewhere else, then an Access Key with role privilege needs to be provided in the Keeper vault to perform the rotation of the end user Access Key.

Rotation Script Logic Flow

1. Admin Credentials Retrieval

The script retrieve admin credentials in three ways:

1. Record directly attached to the post rotation script.

2. The access key provided to the AWS PAM config selected for the rotation. This will be used if no access key is found in the record attached (method 1 above) to the post rotation script.

3. Uses AWS instance role authentication if no credentials are provided from either methods above. The gateway needs to be running on an EC2 Instance with an EC2 Instance Role in place.

2. Key Rotation Logics

The script provides two modes of operation based on the delete_all_keys_before_rotating custom field:

• If False (default), a new access key is created first, then the old ones are deleted, keeping only the newly created key. This will fail if the user account has already two access keys: AWS will not allow the script to create a third one.

• If this custom field is set to True, the script deletes all existing access keys for the IAM user before creating a new one. This helps in the scenario described above where the end user account has already two access keys.

3. Updating the Keeper PAM User Record in the Vault

After key rotation, the script updates the rotated PAM User Keeper record with the new AWS access key ID, secret access key, creation date, and any deleted access keys IDs.

PAM User Record - Fields Requirements

You need to create a PAM User record where the rotation will be configured later on. The fields below need to be created.

Fields required:

Custom fields required:

aws_access_key_id

aws_secret_access_key

CreateDate

Access_Key_ID_Removed_during_previous_rotation

delete_all_keys_before_rotating

NOOP

True

Private Key Type

rsa-ssh

Setting Up the Rotation in the Keeper Vault

Using AWS Instance Role

When the gateway runs in an EC2 instance, you don’t need to provide an admin access key to the script. The gateway will leverage the AWS Instance Role permissions assigned to the VM.

The steps below explains how to set up an EC2 Instance role to the gateway EC2 instance with minimal permissions:

Steps to Add/Configure Instance Role With Minimum Permissions to Rotate Access Keys:

Step 1: Create a Policy in AWS

1. Go to the IAM Management Console.

2. Select Policies and click Create policy.

3. Select JSON and paste the following, make sure to replace your AWS Account ID:

Copy

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "iam:CreateAccessKey",
        "iam:ListAccessKeys",
        "iam:DeleteAccessKey"
      ],
      "Resource": "arn:aws:iam::YOUR_AWS_ACCOUNT_ID_HERE:user/*"
    }
  ]
}

1. Name the policy and save it.

Step 2: Create an IAM Role in AWS

1. Go to the IAM Management Console.

2. Select Roles and click create role.

3. Choose AWS service and select EC2.

1. Attach the necessary IAM policies (e.g., the policy we created above with the minimum permissions).

Step 3: Assign the Role to Your EC2 Instance

1. In the EC2 Management Console, find your instance.

2. Click Actions > Security > Modify IAM Role.

1. Select the role you created and click Update

1. Verify Instance Role Permissions

You can ensure that the instance role has appropriate permissions to interact with IAM by running the command below on the Gateway EC2 Instance:

Copy

aws sts get-caller-identity

After configuring this role, your EC2 instance, in this case your Keeper Gateway, will automatically use the attached role credentials for your script, allowing it to perform actions like creating and deleting IAM access keys without needing explicit access key credentials.

Rotation Configuration From the Vault:

1. Create a shared folder in the vault

2. Create a PAM User record in the shared folder with the fields and custom fields described above.

3. In the Secret Manager tab of the Keeper vault, create a new application for the gateway if there is no gateway yet.

4. Make sure the Application has edit permissions on the shared folder created above.

5. Provision the gateway (gateway tab after selecting the application) on an EC2 instance. On the EC2 Instance run the install command provided by the Keeper vault and make sure boto3 and keeper_secrets_manager_core are installed by running the following commands in the EC2 instance:

Copy

pip3 install boto3
pip3 install keeper_secrets_manager_core

1. In the Secret Manager tab of the Keeper vault, go to the PAM Configurations tab. Create a new PAM configuration if needed.

2. Under Environment you can select “Local Network” or “AWS”. If you select “AWS”, please make sure to leave the “Access Key” and “Secret Access Key” field empty. If you provide one, it will be automatically used by the script instead of using the Instance Role authentication. You will still need to provide the AWS Account ID to the AWS PAM configuration.

3. Select the gateway, select the shared folder and save the PAM configuration.

1. Edit the PAM User record previously described in this documentation:

   • Password Rotation Settings: select your desired schedule and the PAM configuration created above.

   • Add PAM Script to the record: select the provided file below and make sure to specify the script command:

Copy

python3

Using AWS PAM Config

When the gateway does not run in an EC2 instance, it will require an admin access key to authenticate against AWS and rotate another user's access key. Here we will be using the admin access key provided in the AWS PAM Configuration.

Configuration From the Keeper Vault:

1. Create a shared folder in the vault

2. Create a PAM User record in the shared folder with the fields and custom fields described above.

1. In the Secret Manager tab of the Keeper vault, create a new application for the gateway if there is no gateway yet.

2. Make sure the Application has edit permissions on the shared folder created above.

3. Provision the gateway (gateway tab after selecting the application) on a Linux box. Simply run the install command provided by the Keeper vault and make sure boto3 and keeper_secrets_manager_core are installed by running the following commands on the Linux box:

Copy

pip3 install boto3
pip3 install keeper_secrets_manager_core

1. In the Secret Manager tab of the Keeper vault, go to the PAM Configurations tab. Create a new PAM configuration if needed.

2. Under Environment, please select “AWS”, select the Gateway, select the shared folder, provide the “AWS ID”, the “Access Key” and “Secret Access Key”. This will be the admin access key that the script uses to rotate a user access key.

1. Edit the PAM User record previously described in this documentation:

   • Password Rotation Settings: select your desired schedule and the PAM configuration created above.

   • Add PAM Script to the record: select the provided file below and make sure to specify the script command:

Copy

python3

Using Another Keeper Record

When the gateway does not run in an EC2 instance, it will require an admin access key to authenticate against AWS and rotate another user's access key. Here we will be using the admin access key provided in another Keeper record. This option also allows to rotate the admin access key the same way Keeper rotates an user access key.

You may have followed any of the two other tabs available in this doc (Using AWS instance role, or Using AWS PAM Config) to set up the rotation: you will have a PAM configuration that contains or does not contain an access key. Following the steps below will force the use of an admin access key stored in another Keeper record.

Configuration From the Keeper Vault:

When attaching the PAM Script to the PAM user record, it is possible to attach Rotation Credentials.

The attached record could be any record type. It needs at least the two custom fields “aws_access_key_id” and “aws_secret_access_key” with the admin access key.

Using the PAM User record type to store the admin access key allows you to also automate the rotation of the admin access key. Make sure to follow those requirements in that case.

Using AWS AssumeRole to rotate user access keys across other AWS accounts

When attaching a record to the PAM script itself to provide an admin AWS access keys also allows to leverage AWS AssumeRole to rotate an AWS user access key across multiple AWS accounts.

More information about AWS AssumeRole here.

To leverage this feature, you need to add a new custom field to the record attached to the PAM script (Rotation Credentials).

The custom field label needs to be:

Copy

role_arn

This field will contain the role arn from your AWS environment that has the permissions to rotate access keys in other AWS accounts.

When this field exists, the rotation script will use it along with the provided admin access key ID and secret to generate a new temporary access key to rotate the end user’s one in the other AWS account. The script will then update the Keeper PAM User record with the new key and information, the same way it usually does without this extra field.

Python Script

import boto3
import sys
import base64
import json
from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
from botocore.exceptions import ClientError, NoCredentialsError

# sys.stdin is not an array, it cannot be subscripted (i.e., sys.stdin[0])
for base64_params in sys.stdin:
    # Retrieve params from the gateway
    params = json.loads(base64.b64decode(base64_params).decode('utf-8'))
    break

# Retrieve records attached to the post-rotation script in Keeper
records = json.loads(base64.b64decode(params.get('records')).decode('utf-8'))

# Initiate Keeper Secrets Manager SDK using the gateway configuration
secrets_manager = SecretsManager(config=FileKeyValueStorage('/etc/keeper-gateway/gateway-config.json'))

# Function to create a new access key for a user
def create_new_access_key(iam_client, user_name: str) -> tuple:
    new_key = iam_client.create_access_key(UserName=user_name)
    return new_key['AccessKey']['AccessKeyId'], new_key['AccessKey']['SecretAccessKey'], new_key['AccessKey']['CreateDate']

# Function to rotate user's access key
def rotate_user_access_key(iam_client, user_name: str) -> dict:
    if not user_name:
        raise ValueError("User name is required for rotation")

    try:
        # Step 1: Create a new access key for the user
        new_access_key_id, new_secret_access_key, create_date = create_new_access_key(iam_client, user_name)

        print(f"New Access Key created successfully for user {user_name}")

        # Step 2: List all existing access keys for the user
        existing_keys = iam_client.list_access_keys(UserName=user_name)
        deleted_keys = [access_key['AccessKeyId'] for access_key in existing_keys['AccessKeyMetadata']
                        if access_key['AccessKeyId'] != new_access_key_id]

        # Step 3: Delete all other access keys, except the newly created one
        for access_key_id in deleted_keys:
            iam_client.delete_access_key(UserName=user_name, AccessKeyId=access_key_id)

        # Return the results
        return {
            'NewAccessKeyId': new_access_key_id,
            'NewSecretAccessKey': new_secret_access_key,
            'CreateDate': create_date,
            'DeletedAccessKeys': deleted_keys
        }

    except ClientError as e:
        print(f"An error occurred: {e}")
        raise e

# Function to delete all keys and then rotate user's access key
def delete_then_rotate_user_access_key(iam_client, user_name: str) -> dict:
    try:
        # Step 1: List all existing access keys for the user
        existing_keys = iam_client.list_access_keys(UserName=user_name)
        deleted_keys = [access_key['AccessKeyId'] for access_key in existing_keys['AccessKeyMetadata']]

        # Step 2: Delete all keys
        for access_key_id in deleted_keys:
            iam_client.delete_access_key(UserName=user_name, AccessKeyId=access_key_id)

        # Step 3: Create a new access key for the user
        new_access_key_id, new_secret_access_key, create_date = create_new_access_key(iam_client, user_name)

        print(f"New Access Key created successfully for user {user_name}")

        # Return the results
        return {
            'NewAccessKeyId': new_access_key_id,
            'NewSecretAccessKey': new_secret_access_key,
            'CreateDate': create_date,
            'DeletedAccessKeys': deleted_keys
        }

    except ClientError as e:
        print(f"An error occurred: {e}")
        raise e

# Function to assume the role in the target AWS account
def assume_role_in_target_account(role_arn, session_name='CrossAccountSession'):
    sts_client = boto3.client('sts')
    try:
        assumed_role = sts_client.assume_role(
            RoleArn=role_arn,
            RoleSessionName=session_name
        )
        credentials = assumed_role['Credentials']
        return {
            'aws_access_key_id': credentials['AccessKeyId'],
            'aws_secret_access_key': credentials['SecretAccessKey'],
            'aws_session_token': credentials['SessionToken']
        }
    except ClientError as e:
        print(f"Error assuming role: {e}")
        raise e

# Inputs from the gateway and full PAM user query using KSM
pam_user_to_update = secrets_manager.get_secrets([params.get('userRecordUid')])[0]
user_name = params.get('user')

# Retrieve admin user account access key
aws_admin_cred_provided = False
for record in records:
    if "role_arn" in record: # AssumeRole auth detected from the Keeper record
        aws_admin_cred_provided = True
        role_arn = record["role_arn"]
        aws_access_key_id = record["aws_access_key_id"]
        aws_secret_access_key = record["aws_secret_access_key"]
        print(f"Admin access key provided along with role arn for AWS AssumeRole. Using Access Key ID {aws_access_key_id}, from record UID {record['uid']}.")
        # Assume the role and get temporary credentials
        assumed_role_credentials = assume_role_in_target_account(role_arn)
        # Initialize IAM client using the assumed role's credentials
        iam_client = boto3.client(
            'iam',
            aws_access_key_id=assumed_role_credentials['aws_access_key_id'],
            aws_secret_access_key=assumed_role_credentials['aws_secret_access_key'],
            aws_session_token=assumed_role_credentials['aws_session_token'],
            region_name='us-east-1'
        )
        break
    if "aws_access_key_id" in record:
        aws_admin_cred_provided = True
        aws_access_key_id = record["aws_access_key_id"]
        aws_secret_access_key = record["aws_secret_access_key"]
        print(f"Admin access key provided. Using Access Key ID {aws_access_key_id}, from record UID {record['uid']}.")
        # Initialize IAM client with admin credentials
        iam_client = boto3.client('iam',
                                  aws_access_key_id=aws_access_key_id,
                                  aws_secret_access_key=aws_secret_access_key,
                                  region_name='us-east-1')
        break
    if "accessKeyId" in record:
        aws_admin_cred_provided = True
        aws_access_key_id = record["accessKeyId"]
        aws_secret_access_key = record["accessSecretKey"]
        print(f"Admin access key provided. Using Access Key ID {aws_access_key_id}, from record UID {record['uid']}.")
        # Initialize IAM client with admin credentials
        iam_client = boto3.client('iam',
                                  aws_access_key_id=aws_access_key_id,
                                  aws_secret_access_key=aws_secret_access_key,
                                  region_name='us-east-1')
        break
else:
    try:
        # Try to retrieve admin access key from the PAM config using Keeper Secrets Manager
        pam_config = secrets_manager.get_secrets([params.get('providerRecordUid')])[0]
        aws_access_key_id = pam_config.field('accessKeyId', single=True)
        aws_secret_access_key = pam_config.field('accessSecretKey', single=True)

        # Check if keys are retrieved successfully
        if aws_access_key_id and aws_secret_access_key:
            aws_admin_cred_provided = True
            print(f"Admin access key retrieved from the PAM Config. Using Access Key ID {aws_access_key_id}, from the PAM Config.")
            # Initialize IAM client with admin credentials
            iam_client = boto3.client('iam',
                                      aws_access_key_id=aws_access_key_id,
                                      aws_secret_access_key=aws_secret_access_key,
                                      region_name='us-east-1')
        else:
            print("Access key ID or secret key not found in the retrieved Keeper Secrets Manager record.")
    except Exception as e:
        # Handle any error that occurs during retrieval
        print(f"Error retrieving admin access key: {e}")

# Check for instance role credentials if no admin access key is provided
if not aws_admin_cred_provided:
    print("No admin access key provided. Checking for instance role authentication...")
    try:
        # Test if instance role credentials are available by creating an IAM client without credentials
        iam_client = boto3.client('iam')
        iam_client.list_access_keys(UserName=user_name)  # Test if we can access the API
        aws_admin_cred_provided = True
        print("Instance role credentials found. Using instance role authentication.")
    except NoCredentialsError:
        print("No instance role credentials available.")
    except ClientError as e:
        print(f"Error using instance role credentials: {e}")

# Exit if no credentials were provided
if not aws_admin_cred_provided:
    raise RuntimeError("No admin access key or instance role credentials provided. The script will exit.")

# Check if the user specified a delete_all_keys_before_rotating custom field
try:
    delete_all_keys_before_rotating = pam_user_to_update.custom_field('delete_all_keys_before_rotating', single=True)
    delete_all_keys_before_rotating = str(delete_all_keys_before_rotating).lower() in ['true', 'yes', '1']
except Exception as e:
    print(f"OPTIONAL field 'delete_all_keys_before_rotating' not found: {e}")
    delete_all_keys_before_rotating = False  # Set to false if an error occurs

# Call the right rotate function based on user parameters
if delete_all_keys_before_rotating:
    result = delete_then_rotate_user_access_key(iam_client, user_name=user_name)
else:
    result = rotate_user_access_key(iam_client, user_name=user_name)

if result:
    print("\nRotation Result:")
    print(f"New Access Key ID: {result['NewAccessKeyId']}")
    print(f"Create Date: {result['CreateDate']}")
    print(f"Deleted Access Keys: {result['DeletedAccessKeys']}")

    # Update the PAM User record in Keeper
    pam_user_to_update.custom_field('aws_access_key_id', result['NewAccessKeyId'])
    pam_user_to_update.custom_field('aws_secret_access_key', result['NewSecretAccessKey'])
    create_date_str = result['CreateDate'].isoformat() if hasattr(result['CreateDate'], 'isoformat') else str(result['CreateDate'])  # Convert the create_date to string format
    pam_user_to_update.custom_field('CreateDate', create_date_str)
    deleted_keys_str = ', '.join(result['DeletedAccessKeys'])  # Convert deleted access keys to a comma-separated string
    pam_user_to_update.custom_field('Access_Key_ID_Removed_during_previous_rotation', deleted_keys_str)
    secrets_manager.save(pam_user_to_update)

Overview

In this section, you will learn how to rotate DB User or Admin credentials on the following AWS Managed Databases:

AWS RDS for MySQL:

AWS RDS for SQL Server:

AWS RDS for PostgreSQL

AWS RDS for MariaDB

AWS RDS for Oracle:

If you are running a database directly on an EC2 instance in your AWS environment instead of using a managed service, refer to the Local Network > Database documentation for rotating passwords.

Overview

In this guide, you'll learn how to rotate passwords for AWS MySQL Database User and Admin accounts on your AWS environment using Keeper Rotation. RDS for MySQL is an AWS managed resource where the MySQL Admin Credentials are defined in the PAM Database record type and the configurations of the MySQL Users are defined in the PAM User record type.

For Amazon RDS, the AWS SDK will be used to rotate the password of Database Admin Accounts. To rotate the passwords of Regular Database Users, Keeper connects to the DB instance with the provided admin credentials and executes the necessary SQL statements to change the password.

Prerequisites

This guide assumes the following tasks have already taken place:

• Keeper Secrets Manager is enabled for your role

• Keeper Rotation is enabled for your role

• A Keeper Secrets Manager application has been created

• A Keeper Rotation gateway is already installed, running, and is able to communicate with your AWS MySQL Database

• Your AWS environment is configured per our documentation

1. Set up PAM Database Records

The PAM Database record contains the admin credentials and necessary configurations to connect to the MySQL RDS instance on AWS. Keeper Rotation will use these provided configurations to rotate passwords of regular database user accounts in the MySQL RDS instance. These provided admin credentials need to also have sufficient database permissions to successfully change the credentials of the database user accounts.

The following table lists all the required fields on the PAM Database Record:

Note: Adding Provider Region and Database ID will enable managing the PAM Database Record through the SDK.

This PAM Database Record with the admin credential needs to be in a shared folder that is shared to the KSM application created in the pre-requisites. Only the KSM application needs access to this privileged account, it does not need to be shared with any users

2. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

If you are creating a new PAM Configuration, login to the Keeper Vault and select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration".

The following table lists all the required fields on the PAM Configuration Record:

For more details on all the configurable fields in the PAM Configuration record, visit this page.

3. Set up PAM User Records

Keeper Rotation will use the credentials in the PAM Database record to rotate the PAM User records on your AWS environment. The PAM User credential needs to be in a shared folder that is shared to the KSM application created in the prerequisites.

The following table lists all the required fields on the PAM User record:

4. Configure Rotation on the PAM User records

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select the desired schedule and password complexity.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• The "Resource Credential" field should select the PAM Database credential setup from Step 1.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Overview

In this guide, you'll learn how to rotate passwords for AWS SQL Server Database User and Admin accounts on your AWS environment using Keeper Rotation. RDS for SQL Server is an AWS managed resource where the SQL Server Admin Credentials are defined in the PAM Database record type and the configurations of the SQL Server Users are defined in the PAM User record type.

For Amazon RDS, the AWS SDK will be used to rotate the password of Database Admin Accounts. To rotate the passwords of Regular Database Users, Keeper connects to the DB instance with the provided admin credentials and executes the necessary SQL statements to change the password.

Prerequisites

This guide assumes the following tasks have already taken place:

• Keeper Secrets Manager is enabled for your role

• Keeper Rotation is enabled for your role

• A Keeper Secrets Manager application has been created

• A Keeper Rotation gateway is already installed, running, and is able to communicate with your AWS SQL Server Database

• If the Gateway is installed on a Linux or macOS server, install the Microsoft ODBC driver

• Your AWS environment is configured per our documentation

1. Set up a PAM Database Record

The PAM Database record contains the admin credentials and necessary configurations to connect to the SQL Server RDS instance on AWS. Keeper Rotation will use these provided configurations to rotate passwords of regular database user accounts in the SQL Server RDS instance. These provided admin credentials need to also have sufficient database permissions to successfully change the credentials of the database user accounts.

The following table lists all the required fields on the PAM Database Record:

Note: Adding Provider Region and Database ID will enable managing the PAM Database Record through the SDK.

This PAM Database Record with the admin credential needs to be in a shared folder that is shared to the KSM application created in the pre-requisites. Only the KSM application needs access to this privileged account, it does not need to be shared with any users

2. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

If you are creating a new PAM Configuration, login to the Keeper Vault and select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration".

The following table lists all the required fields on the PAM Configuration Record:

For more details on all the configurable fields in the PAM Configuration record, visit this page.

3. Set up PAM User Records

Keeper Rotation will use the credentials in the PAM Database record to rotate the PAM User records on your AWS environment. The PAM User credential needs to be in a shared folder that is shared to the KSM application created in the prerequisites.

The following table lists all the required fields on the PAM User record:

4. Configure Rotation on the PAM User records

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select the desired schedule and password complexity.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• The "Resource Credential" field should select the PAM Database credential setup from Step 1.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Overview

In this guide, you'll learn how to rotate passwords for AWS PostgreSQL Database User and Admin accounts on your AWS environment using Keeper Rotation. RDS for PostgreSQL is an AWS managed resource where the PostgreSQL Admin Credentials are defined in the PAM Database record type and the configurations of the PostgreSQL Users are defined in the PAM User record type.

For Amazon RDS, the AWS SDK will be used to rotate the password of Database Admin Accounts. To rotate the passwords of Regular Database Users, Keeper connects to the DB instance with the provided admin credentials and executes the necessary SQL statements to change the password.

Prerequisites

This guide assumes the following tasks have already taken place:

• Keeper Secrets Manager is enabled for your role

• Keeper Rotation is enabled for your role

• A Keeper Secrets Manager application has been created

• A Keeper Rotation gateway is already installed, running, and is able to communicate with your AWS PostgreSQL Database

• Your AWS environment is configured per our documentation

1. Set up a PAM Database Record

The PAM Database record contains the admin credentials and necessary configurations to connect to the PostgreSQL RDS instance on AWS. Keeper Rotation will use these provided configurations to rotate passwords of regular database user accounts in the PostgreSQL RDS instance. These provided admin credentials need to also have sufficient database permissions to successfully change the credentials of the database user accounts.

The following table lists all the required fields on the PAM Database Record:

Note: Adding Provider Region and Database ID will enable managing the PAM Database Record through the SDK.

This PAM Database Record with the admin credential needs to be in a shared folder that is shared to the KSM application created in the pre-requisites. Only the KSM application needs access to this privileged account, it does not need to be shared with any users

2. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

If you are creating a new PAM Configuration, login to the Keeper Vault and select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration".

The following table lists all the required fields on the PAM Configuration Record:

For more details on all the configurable fields in the PAM Configuration record, visit this page.

3. Set up PAM User Records

Keeper Rotation will use the credentials in the PAM Database record to rotate the PAM User records on your AWS environment. The PAM User credential needs to be in a shared folder that is shared to the KSM application created in the prerequisites.

The following table lists all the required fields on the PAM User record:

4. Configure Rotation on the PAM User records

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select the desired schedule and password complexity.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• The "Resource Credential" field should select the PAM Database credential setup from Step 1.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Overview

In this guide, you'll learn how to rotate passwords for AWS MariaDB Database User and Admin accounts on your AWS environment using Keeper Rotation. RDS for MariaDB is an AWS managed resource where the MariaDB Admin Credentials are defined in the PAM Database record type and the configurations of the MySQL Users are defined in the PAM User record type.

For Amazon RDS, the AWS SDK will be used to rotate the password of Database Admin Accounts. To rotate the passwords of Regular Database Users, Keeper connects to the DB instance with the provided admin credentials and executes the necessary SQL statements to change the password.

Prerequisites

This guide assumes the following tasks have already taken place:

• Keeper Secrets Manager is enabled for your role

• Keeper Rotation is enabled for your role

• A Keeper Secrets Manager application has been created

• A Keeper Rotation gateway is already installed, running, and is able to communicate with your AWS MariaDB Database

• Your AWS environment is configured per our documentation

1. Set up PAM Database Record

The PAM Database record contains the admin credentials and necessary configurations to connect to the MariaDB RDS instance on AWS. Keeper Rotation will use these provided configurations to rotate passwords of regular database user accounts in the MariaDB RDS instance. These provided admin credentials need to also have sufficient database permissions to successfully change the credentials of the database user accounts.

The following table lists all the required fields on the PAM Database Record:

Note: Adding Provider Region and Database ID will enable managing the PAM Database Record through the SDK.

This PAM Database Record with the admin credential needs to be in a shared folder that is shared to the KSM application created in the pre-requisites. Only the KSM application needs access to this privileged account, it does not need to be shared with any users

2. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

If you are creating a new PAM Configuration, login to the Keeper Vault and select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration".

The following table lists all the required fields on the PAM Configuration Record:

For more details on all the configurable fields in the PAM Configuration record, visit this page.

3. Set up PAM User Records

Keeper Rotation will use the credentials in the PAM Database record to rotate the PAM User records on your AWS environment. The PAM User credential needs to be in a shared folder that is shared to the KSM application created in the prerequisites.

The following table lists all the required fields on the PAM User record:

4. Configure Rotation on the PAM User records

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select the desired schedule and password complexity.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• The "Resource Credential" field should select the PAM Database credential setup from Step 1.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Overview

In this guide, you'll learn how to rotate passwords for AWS Oracle Database User and Admin accounts on your AWS environment using Keeper Rotation. RDS for Oracle is an AWS managed resource where the Oracle Admin Credentials are defined in the PAM Database record type and the configurations of the MySQL Users are defined in the PAM User record type.

For Amazon RDS, the AWS SDK will be used to rotate the password of Database Admin Accounts. To rotate the passwords of Regular Database Users, Keeper connects to the DB instance with the provided admin credentials and executes the necessary SQL statements to change the password.

Prerequisites

This guide assumes the following tasks have already taken place:

• Keeper Secrets Manager is enabled for your role

• Keeper Rotation is enabled for your role

• A Keeper Secrets Manager application has been created

• A Keeper Rotation gateway is already installed, running, and is able to communicate with your AWS Oracle Database

• Your AWS environment is configured per our documentation

1. Set up a PAM Database Record

The PAM Database record contains the admin credentials and necessary configurations to connect to the Oracle RDS instance on AWS. Keeper Rotation will use these provided configurations to rotate passwords of regular database user accounts in the Oracle RDS instance. These provided admin credentials need to also have sufficient database permissions to successfully change the credentials of the database user accounts.

The following table lists all the required fields on the PAM Database Record:

Note: Adding Provider Region and Database ID will enable managing the PAM Database Record through the SDK.

This PAM Database Record with the admin credential needs to be in a shared folder that is shared to the KSM application created in the pre-requisites. Only the KSM application needs access to this privileged account, it does not need to be shared with any users

2. Set up PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

If you are creating a new PAM Configuration, login to the Keeper Vault and select "Secrets Manager", then select the "PAM Configurations" tab, and click on "New Configuration".

The following table lists all the required fields on the PAM Configuration Record:

For more details on all the configurable fields in the PAM Configuration record, visit this page.

3. Set up PAM User Records

Keeper Rotation will use the credentials in the PAM Database record to rotate the PAM User records on your AWS environment. The PAM User credential needs to be in a shared folder that is shared to the KSM application created in the prerequisites.

The following table lists all the required fields on the PAM User record:

4. Configure Rotation on the PAM User records

Select the PAM User record(s) from Step 3, edit the record and open the "Password Rotation Settings".

• Select the desired schedule and password complexity.

• The "Rotation Settings" should use the PAM Configuration setup previously.

• The "Resource Credential" field should select the PAM Database credential setup from Step 1.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Any user with edit rights to a PAM User record has the ability to setup rotation for that record.

Overview

In this section, you will learn how to rotate user credentials within a Local Network environment across various target systems.

A "local network" simply means any resource that has line of sight access from the Keeper Gateway. This configuration can be used in any cloud or managed environment. Native protocols are used to communicate to the target resources and perform rotations.

Setup Steps

At a high level, the following steps are needed to successfully rotate passwords on a network:

1. Create Shared Folders to hold the PAM records involved in rotation

2. Create PAM Machine, PAM Database and PAM Directory records representing each resource

3. Create PAM User records that contain the necessary account credentials for each resource

4. Link the PAM User record to the PAM Resource record.

5. Assign a Secrets Manager Application to all of the shared folders that hold the PAM records

6. Install a Keeper Gateway and add it to the Secrets Manager application

7. Create a PAM Configuration with the AWS environment setting

8. Configure Rotation settings on the PAM User records

Use Cases

• Active Directory User

• Windows User

• Linux User

• macOS User

• Database

Overview

In this guide, you'll learn how to remotely rotate Active Directory or OpenLDAP user accounts using KeeperPAM.

Prerequisites

This guide assumes the following tasks have already taken place:

• Rotation enforcements are configured for your role

• A Keeper Secrets Manager application has been created

• Your Keeper Gateway is online

• The Keeper Gateway is able to communicate via LDAPS (port 636) or LDAP (port 389) to your directory.

1. Set up a PAM Directory credential

Keeper Rotation will use the linked admin credential to rotate other accounts in your directory. This account does not need to be a domain admin account, but needs to be able to successfully change passwords for other accounts.

PAM Directory Record Fields

2. Set up a PAM Configuration

Note: You can skip this step if you already have a PAM Configuration set up for this environment.

A PAM Configuration associates an environment with a Keeper Gateway and credentials. If you don't have a PAM Configuration set up yet for this use case, create one.

3. Set up PAM User records

KeeperPAM will use the credentials linked from the "PAM Directory" record to rotate other "PAM User" records in your environment. The PAM User credential needs to be saved in a shared folder that is assigned to the secrets manager application. In the example below, the AD user demouser can be rotated.

PAM User Record Fields

If you don't know the user's DN, the following PowerShell command can be used to find it:

Get-ADUser -Identity <username> -Properties DistinguishedName

4. Configure Rotation on the Record

Select the PAM User record, edit the record and open the "Password Rotation Settings".

Any user with edit rights to a PAM User record and enforcement policies allowing rotation has the ability to set up rotation for that record.

• The "Rotation" should be of type "General".

• The "PAM Resource" field should select the "PAM Directory" credential setup previously.

• Select the desired schedule and password complexity.

• Upon saving, the rotation button will be enabled and available to rotate on demand, or via the selected schedule.

Troubleshooting

An easy way to test if LDAP is properly configured is to run 'LDP.exe' and test the connection. If this connection succeeds, then Keeper Rotation should also succeed.

Testing with a Self-Signed Cert

For the purpose of testing an Active Directory user account rotation with Keeper, it is necessary to ensure that the LDAPS connection is active and using a valid certificate. If you are just testing and don't have a production certificate, the instructions below provide you with a self-signed cert.

1

Create a cert

From PowerShell running as an administrator, create a self-signed cert. Note that the subject name and alternate names of the certificate must match with the server hostname. In this example, the primary name is XYZ123.company.local with alternate names company.local and company.

Copy

New-SelfSignedCertificate -DnsName XYZ123.company.local,company.local,company, -CertStoreLocation cert:\LocalMachine\My

2

Install the cert

This script will locate the cert in the personal section of the certificate manager and copy it into the trusted domains. Replace the company parameter in the first line of this script with the domain in step 1.

Copy

# Get the cert we just created
$cert = Get-ChildItem -Path "Cert:\LocalMachine\My" | Where-Object {$_.Subject -like "*company*"}
$thumbprint = ($cert.Thumbprint | Out-String).Trim()

# Copy to NTDS through registry
$certStoreLoc = 'HKLM:/Software/Microsoft/Cryptography/Services/NTDS/SystemCertificates/My/Certificates'
if (!(Test-Path $certStoreLoc)) {
    New-Item $certStoreLoc -Force
}
Copy-Item -Path HKLM:/Software/Microsoft/SystemCertificates/My/Certificates/$thumbprint -Destination $certStoreLoc

# Copy to Trusted Root store
$rootStore = New-Object System.Security.Cryptography.X509Certificates.X509Store([System.Security.Cryptography.X509Certificates.StoreName]::Root, 'LocalMachine')
$rootStore.Open('ReadWrite')
$rootStore.Add($cert)
$rootStore.Close()

3

Restart NTDS

After restarting the NTDS service, the certificate should be installed.

Copy

Restart-Service NTDS -force

4

Check the connectivity

Run 'LDP.exe' and make sure that you're able to connect to the local domain over port 636 with SSL enabled.

Overview

In this guide, you'll learn how to rotate Windows user accounts within your local network using Keeper Rotation. For a high-level overview on the rotation process in the local network, visit this page.

Prerequisites

This guide assumes the following tasks have already taken place:

• Keeper Secrets Manager is enabled for your role

• Keeper Rotation is enabled for your role

• A Keeper Secrets Manager application has been created

• A Keeper Rotation gateway is already installed and showing online

• The Keeper Gateway can communicate over WinRM or SSH to the target machine:

  • WinRM: Enabled and running on port 5986. Verification: Run winrm get winrm/config to verify that WinRM is running. See WinRM setup page for installation help. OR...

  • SSH: Enabled and running on port 22. Verification: Run ssh [your-user]@[your-machine] -p 22 to verify that SSH is running.