Gestión de secretos

Las funciones de rotación incluyen los siguientes cuatro pasos:

1. VERIFY_CONNECTION: verifica la conexión al sistema de destino mediante las credenciales existentes almacenadas en el secreto.
2. CREATE_PENDING_VERSION: crea una nueva versión de secreto pendiente en el secreto.
3. UPDATE_TARGET_SYSTEM: actualiza el sistema de destino con las credenciales almacenadas en la versión de secreto pendiente creada en el segundo paso.
4. PROMOTE_PENDING_VERSION: actualiza el estado del secreto de pendiente a actual.

Manejador de funciones:

El manejador de funciones debe contener la lógica para llamar al paso de rotación adecuado en función del parámetro de paso. Esto se puede lograr mediante el uso de sentencias condicionales IF ELSE o cambiar de caso. El manejador de funciones genera un error si se proporciona un parámetro de paso no válido.

Entrada:

El manejador de funciones espera un único parámetro: SecretRotationInput. secretRotationInput es un POJO (objeto java sin formato) que contiene los parámetros necesarios para la rotación, incluidos secretId(cadena), paso(cadena) y currentVersionNo(largo).

• secretId: identificador de secreto u OCID
• Paso: paso de rotación (debe ser uno de VERIFY_CONNECTION, CREATE_PENDING_VERSION, UPDATE_TARGET_SYSTEM o PROMOTE_PENDING_VERSION)
• currentVersionNo: número de la versión del secreto 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;
}                

Código de controlador de función de ejemplo:

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

Paso 1: VERIFY_CONNECTION

Este paso verifica la conexión con el sistema de destino.

• Entrada: este método espera solo el parámetro SecretId.
• Salida: este método genera la salida SecretRotationOutput.
• Lógica: la función primero intenta recuperar la versión PENDING y verificar la conexión con ella. Esto maneja el escenario de fallo en el que el reintento anterior no pudo ascender la versión PENDING, pero la versión se ha aplicado correctamente al sistema. Si se realiza correctamente, devuelva la respuesta correcta. Si falla, recupere la versión actual y compruebe la conexión. Si se realiza correctamente, devuelva el código de respuesta correcto junto con el número de versión actual. Si no se realiza correctamente, devuelva el error.

Pseudocódigo para 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.

Paso 2: CREATE_PENDING_VERSION

Genera una nueva versión de secreto pendiente.

• Entrada: este método también acepta el parámetro secretId.
• Salida: este método genera la salida SecretRotationOutput.

• Lógica: este método primero comprueba la existencia de una versión del secreto en estado PENDING. Si no existe uno, genera una nueva versión del secreto PENDING. Sin embargo, si ya existe uno, el paso devuelve la respuesta correcta. También puede utilizar el campo de metadatos del secreto para almacenar detalles adicionales sobre la estructura del secreto y puede utilizar la misma estructura al crear una nueva versión del secreto. También puede utilizar la función de generación automática del servicio secreto para generar automáticamente el contenido secreto. La generación automática le permite escribir funciones más genéricas.

Pseudocódigo para 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

Código de ejemplo:

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

Paso 3: UPDATE_TARGET_SYSTEM

Define el secreto pendiente en el sistema de destino.

• Entrada: este método acepta currentVersionNo y secretId.
• Salida: este método también genera la salida SecretRotationOutput.
• Lógica: este método primero intenta conectarse al sistema de destino con la versión del secreto PENDING y vuelve cuando se realiza correctamente. Esto también gestiona el escenario de fallo en el que el reintento anterior no pudo ascender la versión pendiente, pero la versión se ha aplicado correctamente al sistema. Si esto falla, intenta conectarse con la versión del secreto CURRENT. Si la versión del secreto actual se realiza correctamente, define la contraseña PENDING como la contraseña de usuario en el sistema de destino.

Pseudocódigo para 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.

Código de ejemplo:

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

Paso 4: PROMOTE_PENDING_VERSION

Finalice la rotación marcando el secreto pendiente como actual.

• Entrada: este método acepta currentVersionNo y secretId.
• Salida: este método también genera la salida SecretRotationOutput.
• Lógica: llame al servicio secreto para promocionar la versión PENDING a CURRENT. UpdateRequest debe especificar qué versión se debe promocionar a CURRENT.

Pseudocódigo para PROMOTE_PENDING_VERSION

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

Código de ejemplo:

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