Gerenciando Segredos

As funções de rotação incluíam as seguintes quatro etapas:

1. VERIFY_CONNECTION: Verifica a conexão com o sistema de destino usando as credenciais existentes armazenadas no segredo.
2. CREATE_PENDING_VERSION: Cria uma nova versão de segredo pendente no segredo.
3. UPDATE_TARGET_SYSTEM: Atualiza o sistema de destino com as credenciais armazenadas na versão de segredo pendente criada na segunda etapa.
4. PROMOTE_PENDING_VERSION: Atualiza o estado do segredo de pendente para atual.

Handler de funções:

O handler de função deve conter a lógica para chamar a etapa de rotação apropriada com base no parâmetro de etapa. Isso pode ser feito usando instruções condicionais IF ELSE ou switch case. O handler de função gerará um erro se um parâmetro de etapa inválido for fornecido.

Entrada:

O handler de função espera um único parâmetro: SecretRotationInput. O secretRotationInput é um POJO (objeto java Simplesmente antigo) que contém os parâmetros necessários para a rotação, incluindo secretId(String), step(String) e currentVersionNo(Long).

• secretId: O identificador ou OCID do segredo
• etapa: A etapa de rotação (Deve ser uma das seguintes: VERIFY_CONNECTION, CREATE_PENDING_VERSION, UPDATE_TARGET_SYSTEM ou PROMOTE_PENDING_VERSION)
• currentVersionNo: O número da versão do segredo 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;
}                

Exemplo de código do handler de função:

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

Etapa 1: VERIFY_CONNECTION

Esta etapa verifica a conexão com o sistema de destino.

• Entrada: Esse método espera somente o parâmetro SecretId.
• Saída: Este método gera a saída SecretRotationOutput.
• Lógica: A função primeiro tenta extrair a versão PENDING e verificar a conexão com ela. Isso trata o cenário de falha em que a nova tentativa anterior falhou ao promover a versão PENDING, mas a versão foi aplicada com sucesso ao sistema. Se for bem-sucedido, retorne a resposta de sucesso. Se falhar, extraia a versão atual e verifique a conexão. Se isso for bem-sucedido, retorne o código de resposta bem-sucedido juntamente com o número da versão atual. Se o erro não for bem-sucedido, retorne o erro.

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.

Etapa 2: CREATE_PENDING_VERSION

Gera uma nova versão de segredo pendente.

• Entrada: Esse método também aceita o parâmetro secretId.
• Saída: Este método gera a saída SecretRotationOutput.

• Lógica: Este método primeiro verifica a existência de uma versão de segredo no estado PENDING. Se não existir um, ele gerará uma nova versão de segredo PENDING. No entanto, se já existir uma, a etapa retornará a resposta de sucesso. Você também pode usar o campo de metadados do segredo para armazenar detalhes adicionais sobre a estrutura do segredo e pode usar a mesma estrutura ao criar uma nova versão do segredo. Você também pode usar o recurso de geração automática do serviço Secret para gerar automaticamente o conteúdo do segredo. A geração automática permite escrever funções mais 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 amostra:

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

Etapa 3: UPDATE_TARGET_SYSTEM

Define o segredo pendente no sistema de destino.

• Entrada: Este método aceita currentVersionNo e secretId.
• Saída: Este método também gera a saída SecretRotationOutput.
• Lógica: Este método tenta primeiro fazer log-in no sistema de destino com a versão do segredo PENDING e retorna com sucesso. Isso também trata o cenário de falha em que a nova tentativa anterior falhou ao promover a versão pendente, mas a versão foi aplicada com sucesso ao sistema. Se isso falhar, ele tentará fazer log-in com a versão do segredo CURRENT. Se a versão do segredo atual for bem-sucedida, ela definirá a senha PENDING como a senha do usuário no 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 amostra:

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

Etapa 4: PROMOTE_PENDING_VERSION

Finalize a rotação marcando o segredo pendente como atual.

• Entrada: Este método aceita currentVersionNo e secretId.
• Saída: Este método também gera a saída SecretRotationOutput.
• Lógica: Chame o serviço de Segredo para promover a versão PENDING para CURRENT. UpdateRequest deve especificar qual versão precisa ser promovida para 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 amostra:

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