Gestione dei segreti

Le funzioni di rotazione includevano i seguenti quattro passaggi:

1. VERIFY_CONNECTION: verifica la connessione al sistema di destinazione utilizzando le credenziali esistenti memorizzate nel segreto.
2. CREATE_PENDING_VERSION: crea una nuova versione del segreto in sospeso nel segreto.
3. UPDATE_TARGET_SYSTEM: aggiorna il sistema di destinazione con le credenziali memorizzate nella versione del segreto in sospeso creata nel secondo passo.
4. PROMOTE_PENDING_VERSION: aggiorna lo stato del segreto da in sospeso a corrente.

Gestore funzioni:

L'handler di funzioni deve contenere la logica per chiamare il passo di rotazione appropriato in base al parametro del passo. Ciò può essere ottenuto utilizzando istruzioni condizionali IF ELSE o switch case. L'handler di funzioni genera un errore se viene fornito un parametro passo non valido.

Input:

Il gestore di funzioni prevede un singolo parametro: SecretRotationInput. secretRotationInput è un POJO (Plain-old java object) contenente i parametri necessari per la rotazione, inclusi secretId(String), step(String) e currentVersionNo(Long).

• secretId: identificativo del segreto o OCID
• passo: il passo di rotazione (deve essere VERIFY_CONNECTION, CREATE_PENDING_VERSION, UPDATE_TARGET_SYSTEM o PROMOTE_PENDING_VERSION)
• currentVersionNo: il numero della versione del segreto 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;
}                

Codice del gestore di funzioni di esempio:

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

Fase 1: VERIFY_CONNECTION

Questo passo verifica la connessione al sistema di destinazione.

• Input: questo metodo prevede solo il parametro SecretId.
• Output: questo metodo restituisce SecretRotationOutput.
• Logic: la funzione tenta prima di tutto di recuperare la versione PENDING e verificare la connessione con essa. Gestisce lo scenario di errore in cui il precedente nuovo tentativo non è riuscito a promuovere la versione PENDING, ma la versione è stata applicata al sistema. Se ha successo, restituisce la risposta di successo. In caso di errore, recuperare la versione corrente e controllare la connessione. In caso affermativo, restituire il codice di risposta riuscita insieme al numero di versione corrente. Se non riesce, restituisce l'errore.

Pseudo codice per 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.

Fase 2: CREATE_PENDING_VERSION

Genera una nuova versione del segreto in sospeso.

• Input: questo metodo accetta anche il parametro secretId.
• Output: questo metodo restituisce SecretRotationOutput.

• Logic: questo metodo verifica prima l'esistenza di una versione segreta in stato PENDING. Se non esiste, viene generata una nuova versione del segreto PENDING. Tuttavia, se ne esiste già uno, il passo restituisce la risposta riuscita. È inoltre possibile utilizzare il campo dei metadati segreti per memorizzare dettagli aggiuntivi sulla struttura del segreto e utilizzare la stessa struttura durante la creazione di una nuova versione del segreto. È inoltre possibile utilizzare la funzione di generazione automatica del servizio segreto per generare automaticamente il contenuto del segreto. La generazione automatica consente di scrivere funzioni più generiche.

Pseudo codice per 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

Codice di esempio:

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

Passo 3: UPDATE_TARGET_SYSTEM

Imposta il segreto in sospeso nel sistema di destinazione.

• Input: questo metodo accetta currentVersionNo e secretId.
• Output: questo metodo restituisce anche SecretRotationOutput.
• Logic: questo metodo tenta innanzitutto di eseguire il login al sistema di destinazione con la versione del segreto PENDING e restituisce un risultato positivo. Gestisce anche lo scenario di errore in cui il precedente nuovo tentativo non è riuscito a promuovere la versione in sospeso, ma la versione è stata applicata correttamente al sistema. In caso contrario, tenta di eseguire il login con la versione del segreto CURRENT. Se la versione del segreto corrente riesce, la password PENDING viene impostata come password utente nel sistema di destinazione.

Pseudo codice per 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.

Codice di esempio:

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

Fase 4: PROMOTE_PENDING_VERSION

Terminare la rotazione contrassegnando il segreto in sospeso come corrente.

• Input: questo metodo accetta currentVersionNo e secretId.
• Output: questo metodo restituisce anche SecretRotationOutput.
• Logic: chiamare il servizio segreto per promuovere la versione PENDING in CURRENT. UpdateRequest deve specificare la versione da promuovere in CURRENT.

Pseudo codice per PROMOTE_PENDING_VERSION

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

Codice di esempio:

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