Gestion des clés secrètes

Les fonctions de rotation comprenaient les quatre étapes suivantes :

1. VERIFY_CONNECTION : vérifie la connexion au système cible à l'aide des informations d'identification existantes stockées dans la clé secrète.
2. CREATE_PENDING_VERSION : crée une version de clé secrète en attente dans la clé secrète.
3. UPDATE_TARGET_SYSTEM : met à jour le système cible avec les informations d'identification stockées dans la version de clé secrète en attente créée à la deuxième étape.
4. PROMOTE_PENDING_VERSION : met à jour l'état de la clé secrète de En attente à En cours.

Gestionnaire de fonctions :

Le gestionnaire de fonctions doit contenir la logique permettant d'appeler l'étape de rotation appropriée en fonction du paramètre d'étape. Pour ce faire, vous pouvez utiliser des instructions conditionnelles IF ELSE ou switch case. Le gestionnaire de fonctions génère une erreur si un paramètre d'étape non valide est fourni.

Entrée :

Le gestionnaire de fonctions attend un seul paramètre : SecretRotationInput. secretRotationInput est un objet POJO (Java uni) contenant les paramètres requis pour la rotation, notamment secretId(String), step(String) et currentVersionNo(Long).

• secretId : OCID ou identificateur de clé secrète
• étape : étape de rotation (doit être VERIFY_CONNECTION, CREATE_PENDING_VERSION, UPDATE_TARGET_SYSTEM ou PROMOTE_PENDING_VERSION)
• currentVersionNo : numéro de la version de clé secrète CURRENT

SecretRotationInput POJO

@Getter
@Setter
@ToString(callSuper = true)
@JsonInclude(JsonInclude.Include.NON_NULL)
@AllArgsConstructor
@Builder(toBuilder = true)
public static class SecretRotationInput {
    private String step;
    private Long versionNo;
    private String secretId;
}                

Exemple de code de gestionnaire de fonctions :

public static class SecretRotationOutput {
    int responseCode;
    Long currentVersionNo;
    String returnMessage;
}
 
 
public SecretRotationOutput handleRequest(SecretRotationInput input) {
    switch(input.getStep()) {
        case "VERIFY_CONNECTION":
            return verifyConnection(input.getSecretId());
        case "CREATE_PENDING_VERSION":
            return createNewPendingVersion(input.getSecretId());
        case "UPDATE_TARGET_SYSTEM":
            return updateTargetSystem(input.getSecretId(), input.getVersionNo());
        case "PROMOTE_PENDING_VERSION":
            return promotePendingVersion(input.getSecretId(), input.getVersionNo());
        default:
            log.error("Secret Rotation: invalid rotation step");
            return SecretRotationOutput.builder()
                    .responseCode(400)
                    .currentVersionNo(null)
                    .returnMessage("INVALID STEP")
                    .build();
    }
}

Etape 1 : VERIFY_CONNECTION

Cette étape vérifie la connexion au système cible.

• Entrée : cette méthode attend uniquement le paramètre SecretId.
• Sortie : cette méthode génère la sortie SecretRotationOutput.
• Logique : la fonction tente d'abord d'extraire la version PENDING et de vérifier la connexion avec celle-ci. Cette option gère le scénario d'échec dans lequel la nouvelle tentative précédente n'a pas réussi à promouvoir la version PENDING, mais la version a été appliquée au système. Si elle réussit, renvoyez la réponse de succès. En cas d'échec, extrayez la version actuelle et vérifiez la connexion. Si cela réussit, renvoyez le code de réponse de succès avec le numéro de version actuel. En cas d'échec, renvoyez l'erreur.

Pseudo-code pour VERIFY_CONNECTION

pseudo code for verifyConnection:
    Check if "PENDING" secret version exists
        If it exist, verify connection
            If succeeds, then return success.
    Fetch the "CURRENT" secret version
    Verify connection with "CURRENT" secret version
       If succeeds, return success and the current version number in the response.
        If not, return SecretRotationOutput with appropriate error code and message.

Etape 2 : CREATE_PENDING_VERSION

Génère une nouvelle version de clé secrète en attente.

• Entrée : cette méthode accepte également le paramètre secretId.
• Sortie : cette méthode génère la sortie SecretRotationOutput.

• Logique : cette méthode vérifie d'abord l'existence d'une version de clé secrète à l'état PENDING. S'il n'en existe pas, une nouvelle version de clé secrète PENDING est générée. Toutefois, s'il en existe déjà un, l'étape renvoie la réponse de réussite. Vous pouvez également utiliser le champ de métadonnées de clé secrète pour stocker des détails supplémentaires sur la structure de clé secrète et utiliser la même structure lors de la création d'une version de clé secrète. Vous pouvez également utiliser la fonctionnalité de génération automatique du service de clé secrète pour générer automatiquement le contenu de clé secrète. La génération automatique vous permet d'écrire des fonctions plus génériques.

Pseudo-code pour CREATE_PENDING_VERSION

pseudo code for createPendingVersion:
    Try to get the pending version
        If it succeeds, return success
        Else create a new secret version in "PENDING" state and then return success

Exemple de code :

// Constructor
public void constructorClass() {
     secretsDpClient = SecretsClient.builder()
                    .region(region)
                    .configuration(configuration)
                    .build(auth_provider);
     secretsCpClient = VaultsClient.builder()
                    .region(region)
                    .configuration(configuration)
                    .build(auth_provider);
}
 
private String createNewPassword() {
    // This method must contains the logic to generate the new secret content
}
  
private SecretRotationOutput createNewPendingVersion(SecretRotationInput input) {
    // Make sure the given secret exist
    Secret secret = secretsCpClient.getSecret(GetSecretRequest.builder()
                    .secretId(input.getSecretId())
            .build()).getSecret();
  
    // Now try to get the pending secret version, if that fails, create a new one
    try {
        GetSecretBundleRequest getSecretBundleRequest = GetSecretBundleRequest.builder()
                .secretId(input.getSecretId())
                .stage(GetSecretBundleRequest.Stage.Pending)
                .build();
        secretsDpClient.getSecretBundle(getSecretBundleRequest);
        return SecretRotationOutput.builder()
                .responseCode(200)
                .returnMessage("Successfully retrieved the pending secret version")
                .build();
    } catch (BmcException bmc) {
        // Create a new pending version
        UpdateSecretDetails updateSecretDetails = secret.getIsAutoGenerationEnabled() ? UpdateSecretDetails.builder()
                .secretContent(Base64SecretContentDetails.builder()
                        .stage(SecretContentDetails.Stage.Pending)
                        .build())
                .build() : UpdateSecretDetails.builder()
                .secretContent(Base64SecretContentDetails.builder()
                        .content(createNewPassword())
                        .stage(SecretContentDetails.Stage.Pending)
                        .build())
                .build();
        secretsCpClient.updateSecret(UpdateSecretRequest.builder()
                .secretId(input.getSecretId())
                .updateSecretDetails(updateSecretDetails)
                .build()).getSecret();
        log.info("Successfully added a new version with 'PENDING' stage for secretId {}", input.getSecretId());
        return SecretRotationOutput.builder()
                .responseCode(200)
                .returnMessage("Pending version created successfully")
                .currentVersionNo(input.getVersionNo())
                .build();
    }
}

Etape 3 : UPDATE_TARGET_SYSTEM

Définit la clé secrète en attente dans le système cible.

• Entrée : cette méthode accepte les valeurs currentVersionNo et secretId.
• Sortie : cette méthode génère également le fichier SecretRotationOutput.
• Logique : cette méthode tente d'abord de se connecter au système cible avec la version de clé secrète PENDING et revient en cas de réussite. Cette option gère également le scénario d'échec dans lequel la nouvelle tentative précédente n'a pas réussi à promouvoir la version en attente mais la version a été appliquée avec succès au système. En cas d'échec, il tente de se connecter avec la version de clé secrète CURRENT. Si la version de clé secrète en cours réussit, elle définit le mot de passe PENDING comme mot de passe utilisateur dans le système cible.

Pseudo-code pour UPDATE_TARGET_SYSTEM

Pseudo code for updateTargetSystem:
    Fetch the "PENDING" secret version
    Check the connection with Pending version
        It it works return success and the pending version number in the response
    Fetch the "CURRENT" secret version
    Check the connection with it
        If it works
            Update the target system with "PENDING" version
            Verify that target system is updated.
               if yes then return success and the pending version number in the response 
            else return the appropriate error code and the error message
        If not, return SecretRotationOutput with appropriate error code and message.

Exemple de code :

private SecretRotationOutput updateTargetSystem(String secretId, Long currentVersionNo) {
    // Get the pending secret version
    SecretBundle pendingSecretBundle = secretsDpClient.getSecretBundle(GetSecretBundleRequest.builder()
                    .secretId(secretId)
                    .stage(GetSecretBundleRequest.Stage.Pending)
            .build()).getSecretBundle();
  
    // First try to login with the pending secret, if it succeeds, return
    Connection conn = getConnection(pendingSecretBundle);
    if(conn) {
        log.info("Updated the target system with pending version");
        return SecretRotationOutput.builder()
                    .responseCode(200)
                    .returnMessage("Successfully update target service")
                    .currentVersionNo(pendingSecretBundle.getVersionNumber())
                    .build();
    }
  
    SecretBundle currentSecretBundle = secretsDpClient.getSecretBundle(GetSecretBundleRequest.builder()
                    .versionNumber(currentVersionNo)
                    .secretId(secretId)
            .build()).getSecretBundle();
  
    conn = getConnection(currentSecretBundle);
    if(conn) {
        // Write logic to update the target system and check the connection with the updated password
    } else {
        log.error("Unable to log into system using the current version");
        return SecretRotationOutput.builder()
                .returnMessage("Unable to log into system using the current version")
                .responseCode(400)
                .build();
    }
}

Etape 4 : PROMOTE_PENDING_VERSION

Terminez la rotation en marquant la clé secrète en attente comme étant en cours.

• Entrée : cette méthode accepte les valeurs currentVersionNo et secretId.
• Sortie : cette méthode génère également le fichier SecretRotationOutput.
• Logique : appelez le service de clé secrète pour promouvoir la version PENDING vers CURRENT. UpdateRequest doit indiquer la version à promouvoir vers CURRENT.

Pseudo-code pour PROMOTE_PENDING_VERSION

pseudo code for promotePendingVersion:
    Make updateSecret Api call to promote the specified version to "CURRENT"

Exemple de code :

private SecretRotationOutput promotePendingVersion(String secretId, Long versionNo) {
    try {
        Secret secret = secretsCpClient.updateSecret(UpdateSecretRequest.builder()
                .secretId(secretId)
                .updateSecretDetails(UpdateSecretDetails.builder()
                        .currentVersionNumber(versionNo)
                        .build())
                .opcRequestId(UUID.randomUUID().toString())
                .build()).getSecret();
        log.info("Successfully promoted the version number {} to 'CURRENT'", versionNo);
        return SecretRotationOutput.builder()
                .responseCode(200)
                .currentVersionNo(secret.getCurrentVersionNumber())
                .returnMessage("Successfully promoted the pending version")
                .build();
    } catch (BmcException bmc) {
        log.error("Fail to promote the pending version. SecretId: {}, pendingVersionNo: {}. {}", secretId, versionNo, bmc.getMessage());
        return SecretRotationOutput.builder()
                .returnMessage(bmc.getMessage())
                .responseCode(bmc.getStatusCode())
                .build();
    }
}