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 données d'identification existantes stockées dans la clé secrète.
2. CREATE_PENDING_VERSION : Crée une nouvelle version de clé secrète en attente dans la clé secrète.
3. UPDATE_TARGET_SYSTEM : Met à jour le système cible avec les données 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 à Courant.

Programme de traitement de fonctions :

Le gestionnaire de fonctions doit contenir la logique d'appel de l'étape de rotation appropriée en fonction du paramètre d'étape. Pour ce faire, utilisez des instructions conditionnelles IF ELSE ou changez de cas. Le programme de traitement de fonctions génère une erreur si un paramètre d'étape non valide est fourni.

Entrée :

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

• secretId : Identificateur ou OCID de la clé secrète
• étape : Étape de rotation (doit être l'une des suivantes : 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 programme de traitement de fonction :

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();
    }
}

Étape 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 affiche la sortie SecretRotationOutput.
• Logique : La fonction tente d'abord d'extraire la version PENDING et de vérifier la connexion avec celle-ci. Cela gère le scénario d'échec où la nouvelle tentative précédente n'a pas réussi à promouvoir la version PENDING, mais où la version a été appliquée au système. S'il réussit, renvoyez la réponse de réussite. En cas d'échec, extrayez la version courante et vérifiez la connexion. Si cela réussit, renvoyez le code de réponse de réussite avec le numéro de version courant. Si elle ne réussit pas, 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.

Étape 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 affiche 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, il génère une nouvelle version de clé secrète PENDING. Toutefois, s'il en existe déjà une, 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 nouvelle version de clé secrète. Vous pouvez également utiliser la fonction de génération automatique du service de clé secrète pour générer automatiquement le contenu de la 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();
    }
}

Étape 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 affiche également SecretRotationOutput.
• Logique : Cette méthode tente d'abord de se connecter au système cible avec la version de clé secrète PENDING et retourne avec succès. Cela gère également le scénario d'échec où la nouvelle tentative précédente n'a pas réussi à promouvoir la version en attente, mais où la version a été appliquée avec succès au système. Si cela échoue, il tente de se connecter avec la version de clé secrète CURRENT. Si la version de clé secrète courante réussit, elle définit le mot de passe PENDING comme mot de passe d'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();
    }
}

Étape 4 : PROMOTE_PENDING_VERSION

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

• Entrée : Cette méthode accepte les valeurs currentVersionNo et secretId.
• Sortie : Cette méthode affiche également SecretRotationOutput.
• Logic : Appelez le service de clé secrète pour promouvoir la version PENDING vers CURRENT. UpdateRequest doit spécifier quelle version doit être promue en 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();
    }
}