// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.

//! Command message handlers.

use crate::args::{ArgId, ArgMap, ArgMapExt, ArgTypeMap, ArgTypeSelector};
use crate::crypto::{
    HandshakeMessage, SealingPublicKey, Signature, SigningPublicKey,
};
use crate::dice::{Certificate, DiceInput, InternalInputType};
use crate::encode::{
    decode_and_remove_command_header, decode_args, decode_dice_input,
    decode_internal_inputs, decode_locality, encode_and_insert_response_header,
    encode_args, CommandSelector, ContextHandle, LocalityId, SessionId,
};
use crate::error::DpeResult;
use crate::memory::{Message, SmallMessage};
use log::debug;

/// A struct combining boolean option arguments for the DeriveContext command.
#[derive(Clone, Debug, Eq, PartialEq, Hash)]
pub(crate) struct DeriveContextOptions {
    /// Corresponds to the `retain-parent-context` argument. When this is true
    /// the derivation will result in a new derived context and the parent
    /// context will be retained as is.
    pub(crate) retain_parent_context: bool,
    /// Corresponds to the `allow-new-context-to-derive` argument. The DPE
    /// tracks this permission for every context. It might be false, for
    /// example, when it represents a program that should not be spawning
    /// other programs. If this option is set to true, the derived context will
    /// have this set to true (requires the parent context already has this set
    /// to true).
    pub(crate) allow_new_context_to_derive: bool,
    /// Corresponds to the `create-certificate` argument. If this is true a
    /// certificate will be created for the derived context, otherwise
    /// information that would have gone into the certificate is stored
    /// until a certificate is created.
    pub(crate) create_certificate: bool,
    /// Corresponds to the `return-certificate` argument. If this is true the
    /// new certificate is provided in the command response.
    pub(crate) return_certificate: bool,
    /// Corresponds to the `allow-new-context-to-export` argument. The DPE
    /// tracks this permission for every context. If this is true, the
    /// derived context will have this set to true (requires the parent
    /// context already has this set to true).
    pub(crate) allow_new_context_to_export: bool,
    /// Corresponds to the `export-cdi` argument. If this is true an
    /// export-specific derivation process is followed and the resulting
    /// CDI(s) are provided to the caller.
    pub(crate) export_cdi: bool,
    /// Corresponds to the `recursive` argument. If this is true the derivation
    /// will affect not only the given context but any context previously
    /// derived from the given context.
    pub(crate) recursive: bool,
}

impl Default for DeriveContextOptions {
    fn default() -> Self {
        Self {
            retain_parent_context: false,
            allow_new_context_to_derive: true,
            create_certificate: true,
            return_certificate: false,
            allow_new_context_to_export: false,
            export_cdi: false,
            recursive: false,
        }
    }
}

/// A trait representing the core DPE functionality required to handle commands.
///
/// When handling a command message, exactly one of these methods will be
/// called. The method documentation below is very brief. For details on command
/// behavior, arguments, and DPE concepts, refer to the [DPE
/// specification][dpe_spec]. For details specified by a profile, see the [Open
/// Profile][profile_spec]. In general, the method parameters correspond
/// directly to the command parameters described in the spec.
///
/// # Errors
///
/// Methods in this trait might return [ErrCode::InternalError]. This indicates
/// a problem that is no fault of the caller and not actionable by the caller.
///
/// Methods in this trait might return [ErrCode::InvalidArgument] when the
/// session / locality on which the command was sent is not valid. For example,
/// an implementation might enforce that plaintext commands are not allowed on
/// locality 0.
///
/// Anticipated errors are documented per method but implementations can use any
/// error code.
///
/// [dpe_spec]: https://trustedcomputinggroup.org/wp-content/uploads/DICE-Protection-Environment-Version-1.0_pub.pdf
/// [profile_spec]: ../../docs/specification.md
pub(crate) trait DpeCore {
    /// Returns the locality associated with the current command. This is the
    /// actual locality, not a locality indicated in a command argument. For
    /// example, if an implementation uses locality 0 for clients running on
    /// a main application processor and locality 1 for a separate special
    /// purpose core, this method indicates which of those the current
    /// command originated from. This value is used when the specification
    /// indicates the "current locality".
    fn get_current_locality(&self) -> LocalityId;

    /// Implements the GetProfile DPE command.
    ///
    /// # Returns
    ///
    /// On success, returns a CBOR-encoded profile descriptor.
    ///
    /// # Errors
    ///
    /// This method is expected to succeed during normal operation.
    fn get_profile(&self) -> DpeResult<Message>;

    /// Implements the OpenSession DPE command. On success a new session
    /// endpoint is established in the DPE and will consume DPE resources
    /// until it is closed.
    ///
    /// # Parameters
    ///
    /// * `initiator_handshake`: A handshake message from the client to start a
    ///   session negotiation. The format and semantic of the message depend on
    ///   the handshake protocol.
    ///
    /// # Returns
    ///
    /// On success, a responding handshake message is returned. This message is
    /// sufficient for the client to establish its session endpoint.
    ///
    /// # Errors
    ///
    /// * [`ErrCode::InvalidArgument`]: The intiator handshake could not be
    ///   processed.
    /// * [`ErrCode::OutOfMemory`]: The maximum supported sessions already
    ///   exist.
    fn open_session(
        &mut self,
        initiator_handshake: &HandshakeMessage,
    ) -> DpeResult<HandshakeMessage>;

    /// Implements the CloseSession DPE command. On success the session on which
    /// the command was sent is closed and associated DPE resources are
    /// released. The response message to this command is the last message
    /// encrypted using the session.
    ///
    /// # Errors
    ///
    /// * [`ErrCode::InvalidCommand`]: A plaintext session cannot be closed.
    fn close_session(&mut self) -> DpeResult<()>;

    /// Implements the SyncSession DPE command. On success the target session
    /// state in the DPE is updated. This command is always sent on a
    /// plaintext session because presumably the encrypted session needs to
    /// be synced. This is intended for sessions which require counters
    /// to be maintained at both endpoints to recover from these counters
    /// getting out of sync.
    ///
    /// # Parameters
    ///
    /// * `target_session`: Indicates which session to sync.
    /// * `initiator_counter`: The client's current counter value (for
    ///   encrypting commands).
    ///
    /// # Returns
    ///
    /// On success, returns the DPE's current counter value (for encrypting
    /// responses).
    ///
    /// # Errors
    ///
    /// * [`ErrCode::InvalidCommand`]: This command must be invoked on a
    ///   plaintext session.
    /// * [`ErrCode::InvalidArgument`]: The provided counter is not in an
    ///   acceptable range. For
    /// example, if the counter is lower than the current value.
    fn sync_session(
        &mut self,
        target_session: SessionId,
        initiator_counter: u64,
    ) -> DpeResult<u64>;

    /// Implements the InitializeContext DPE command. On success a new context
    /// is established in the DPE and will consume DPE resources until it is
    /// destroyed.
    ///
    /// # Parameters
    ///
    /// * `simulation`: Whether the new context should be a simulation context.
    /// * `use_default_context`: If true, the default context will be
    ///   initialized.
    /// * `seed`: A seed value to use when deriving the initial CDI value(s).
    ///
    /// # Returns
    ///
    /// On success, returns a context handle that can be used to reference the
    /// new context in a subsequent command. If `use_default_context` was
    /// set, this will be `None`.
    ///
    /// # Errors
    ///
    /// *[`ErrCode::InvalidArgument`]: A given argument is malformed or is not
    /// supported by the implementation, for example if simulation contexts
    /// are not supported but `simulation` is true.
    /// *[`ErrCode::OutOfMemory`]: The maximum supported contexts already exist.
    fn initialize_context(
        &mut self,
        simulation: bool,
        use_default_context: bool,
        seed: &[u8],
    ) -> DpeResult<Option<ContextHandle>>;

    /// Implements the DeriveContext DPE command. This command is the main DPE
    /// command and essentially runs the DICE process with the given
    /// context. It can have a variety of effects on the state of the DPE
    /// depending on the arguments.
    ///
    /// # Parameters
    ///
    /// * `options`: Command options. See [`DeriveContextOptions`].
    /// * `handle`: The context to derive from, or, the parent context.
    /// * `new_session_initiator_handshake`: If not None, contains a handshake
    ///   message used to negotiate a new session for the derived context.
    /// * `version_info`: Specifies version info to associate with the derived
    ///   context. This is used for evaluating unseal policies.
    /// * `dice_input`: Describes the system transition represented by the
    ///   derivation. This is used as input to the derivation.
    /// * `internal_inputs`: Indicates internal input values to be included in
    ///   the derivation. This is similar to `dice_input` but the values are
    ///   only known to the DPE.
    /// * `target_locality`: Indicates the locality that should be associated
    ///   with the derived context. Usually this is the current locality.
    ///
    /// # Returns
    ///
    /// * `new_context_handle`: A handle to the new derived context, when
    ///   available
    /// * `new_session_responder_handshake`: A handshake message corresponding
    ///   to `new_session_initiator_handshake`, when a new session was created.
    /// * `new_parent_context_handle`: A new handle to the parent context, when
    ///   retained.
    /// * `new_certificate`: The generated certificate, when requested.
    /// * `exported_cdi`: The exported CDI values, when export was requested.
    ///
    /// # Errors
    ///
    /// * [`ErrCode::InvalidArgument`]: Arguments can be invalid in multiple
    ///   ways:
    ///     * An argument is malformed.
    ///     * An argument has an invalid value, for example:
    ///         * The given context handle is not found.
    ///         * The target locality is not in the supported range.
    ///         * A new session is initiated on a locality that does not support
    ///           encrypted sessions.
    ///     * Arguments are incompatible per the DPE spec, for example:
    ///         * A default context is retained but neither a new session nor
    ///           new locality is given.
    ///         * Certificate return or CDI export requested for a recursive
    ///           derivation.
    ///         * Export is requested for a new target locality.
    ///     * Arguments would violate a DPE rule or permission, per the spec.
    ///       For example:
    ///         * Derivation is not allowed for the given context.
    ///         * Export or allow export is requested but export is not allowed
    ///           for the given context.
    ///         * Cannot target a locality that supports encrypted sessions from
    ///           one that does not.
    ///         * Export is requested for a simulation context.
    ///         * A new default context is targeted but already initialized.
    /// * [`ErrCode::OutOfMemory`]: A new context or session were requested but
    ///   not available.
    #[allow(clippy::type_complexity, clippy::too_many_arguments)]
    fn derive_context(
        &mut self,
        options: &DeriveContextOptions,
        handle: Option<&ContextHandle>,
        new_session_initiator_handshake: Option<&HandshakeMessage>,
        version_info: Option<(usize, u64)>,
        dice_input: &DiceInput,
        internal_inputs: &[InternalInputType],
        target_locality: LocalityId,
    ) -> DpeResult<(
        /* new_context_handle: */ Option<ContextHandle>,
        /* new_session_responder_handshake: */ Option<HandshakeMessage>,
        /* new_parent_context_handle: */ Option<ContextHandle>,
        /* new_certificate: */ Option<Certificate>,
        /* exported_cdi: */ Option<SmallMessage>,
    )>;

    /// Implements the GetCertificateChain DPE command.
    ///
    /// # Parameters
    ///
    /// * `handle`: The context to get the certificate chain from.
    /// * `retain_context`: Whether the context will be used again, if so a new
    ///   handle will be provided.
    /// * `clear_from_context`: Whether to clear the certificate chain from the
    ///   DPE on success. This allows the DPE to reclaim resources.
    /// * `encoded_certificate_chain`: The certificate chain data.
    /// * `new_handle`: The new handle, if provided.
    ///
    /// # Errors
    ///
    /// * [`ErrCode::InvalidArgument`]: The given context contains info not yet
    ///   added to a certificate.
    fn get_certificate_chain(
        &mut self,
        handle: Option<&ContextHandle>,
        retain_context: bool,
        clear_from_context: bool,
    ) -> DpeResult<(
        /* encoded_certificate_chain: */ Message,
        /* new_handle: */ Option<ContextHandle>,
    )>;

    /// Implements the CertifyKey DPE command. This command certifies a leaf key
    /// using the given context.
    ///
    /// # Parameters
    ///
    /// * `handle`: The context to certify with.
    /// * `retain_context`: Whether the context will be used again, if so a new
    ///   handle will be provided.
    /// * `public_key`: If provided, will be the key that is certified. If not
    ///   provided a key will be derived by the DPE and returned.
    /// * `label`: Used in the leaf key derivation.
    /// * `additional_input`: Optional data that allows implementations to
    ///   further customize the certificate.
    ///
    /// # Returns
    ///
    /// * `certificate`: The generated certificate.
    /// * `derived_public_key`: The public key of the derived key pair. The same
    ///   key pair can be derived in other commands like [`sign`] by using the
    ///   same label.
    /// * `new_handle`: The new handle, if provided.
    ///
    /// # Errors
    ///
    /// * [`ErrCode::InvalidArgument`]: Returned if an argument is malformed,
    ///   the handle cannot be found, or if `public_key` was provided with a
    ///   simulation context (simulation contexts cannot be used to certify
    ///   external keys).
    #[allow(clippy::too_many_arguments)]
    fn certify_key(
        &mut self,
        handle: Option<&ContextHandle>,
        retain_context: bool,
        public_key: Option<&SigningPublicKey>,
        label: &[u8],
        additional_input: &[u8],
    ) -> DpeResult<(
        /* certificate: */ Certificate,
        /* derived_public_key: */ Option<SigningPublicKey>,
        /* new_handle: */ Option<ContextHandle>,
    )>;

    /// Implements the Sign DPE command. This command signs with a derived leaf
    /// key.
    ///
    /// # Parameters
    ///
    /// * `handle`: The context to sign with.
    /// * `retain_context`: Whether the context will be used again, if so a new
    ///   handle will be provided.
    /// * `label`: Used in the key derivation.
    /// * `is_symmetric`: If true, a symmetric key is derived (e.g. HMAC)
    /// * `to_be_signed`: The data to be signed.
    ///
    /// # Returns
    ///
    /// * `signature`: The generated signature.
    /// * `new_handle`: The new handle, if provided.
    ///
    /// # Errors
    ///
    /// * `[ErrCode::InvalidArgument`]: Returned if an argument is malformed,
    ///   the handle cannot be found, or if the given context is a simulation
    ///   context (signing with a simulation context is not allowed).
    #[allow(clippy::too_many_arguments)]
    fn sign(
        &mut self,
        handle: Option<&ContextHandle>,
        retain_context: bool,
        label: &[u8],
        is_symmetric: bool,
        to_be_signed: &[u8],
    ) -> DpeResult<(
        /* signature: */ Signature,
        /* new_handle: */ Option<ContextHandle>,
    )>;

    /// Implements the Seal DPE command. This command seals data with a
    /// symmetric key derived from the given context. Note, sealing with an
    /// asymmetric key does not need the DPE, see [`derive_sealing_public_key`].
    ///
    /// # Parameters
    ///
    /// * `handle`: The context to seal with.
    /// * `retain_context`: Whether the context will be used again, if so a new
    ///   handle will be provided.
    /// * `unseal_policy`: The policy that will be required to unseal.
    /// * `label`: Used in the key derivation.
    /// * `to_be_sealed`: The data to be sealed.
    ///
    /// # Returns
    ///
    /// * `sealed_data`: The encrypted sealed data.
    /// * `new_handle`: The new handle, if provided.
    ///
    /// # Errors
    ///
    /// * `[ErrCode::InvalidArgument`]: Returned if an argument is malformed or
    ///   the handle cannot be found.
    #[allow(clippy::too_many_arguments)]
    fn seal(
        &mut self,
        handle: Option<&ContextHandle>,
        retain_context: bool,
        unseal_policy: &[u8],
        label: &[u8],
        data_to_seal: &[u8],
    ) -> DpeResult<(
        /* sealed_data: */ Message,
        /* new_handle: */ Option<ContextHandle>,
    )>;

    /// Implements the Unseal DPE command. This command unseals data that was
    /// sealed with either a symmetric or asymmetric key.
    ///
    /// # Parameters
    ///
    /// * `handle`: The context to unseal with.
    /// * `retain_context`: Whether the context will be used again, if so a new
    ///   handle will be provided.
    /// * `is_symmetric`: Whether the data was sealed with a symmetric key.
    /// * `unseal_policy`: The policy required to unseal.
    /// * `label`: Used in the key derivation.
    /// * `data_to_unsealed`: The data to be unsealed.
    ///
    /// # Returns
    ///
    /// * `unsealed_data`: The unsealed data.
    /// * `new_handle`: The new handle, if provided.
    ///
    /// # Errors
    ///
    /// * `[ErrCode::InvalidArgument`]: Returned if an argument is malformed,
    ///   the handle cannot be found, if the given context is a simulation
    ///   context (unsealing with a simulation context is not allowed), or the
    ///   unseal policy does not match (or its requirements are not met).
    #[allow(clippy::too_many_arguments)]
    fn unseal(
        &mut self,
        handle: Option<&ContextHandle>,
        retain_context: bool,
        is_asymmetric: bool,
        unseal_policy: &[u8],
        label: &[u8],
        data_to_unseal: &[u8],
    ) -> DpeResult<(
        /* unsealed_data: */ Message,
        /* new_handle: */ Option<ContextHandle>,
    )>;

    /// Implements the DeriveSealingPublicKey DPE command. This command derives
    /// a public key that can be used for asymmetric sealing.
    ///
    /// # Parameters
    ///
    /// * `handle`: The context to derive from.
    /// * `retain_context`: Whether the context will be used again, if so a new
    ///   handle will be provided.
    /// * `unseal_policy`: The policy that will be required to unseal.
    /// * `label`: Used in the key derivation.
    ///
    /// # Returns
    ///
    /// * `public_key`: The derived public key.
    /// * `new_handle`: The new handle, if provided.
    ///
    /// # Errors
    ///
    /// * `[ErrCode::InvalidArgument`]: Returned if an argument is malformed or
    ///   the handle cannot be found.
    fn derive_sealing_public_key(
        &mut self,
        handle: Option<&ContextHandle>,
        retain_context: bool,
        unseal_policy: &[u8],
        label: &[u8],
    ) -> DpeResult<(
        /* public_key: */ SealingPublicKey,
        /* new_handle: */ Option<ContextHandle>,
    )>;

    /// Implements the RotateContextHandle DPE command. This command generates
    /// a new handle for a context or changes handle properties. This command
    /// does not modify the state of the context itself (beyond handle/locality
    /// association).
    ///
    /// # Parameters
    ///
    /// * `handle`: The context handle to rotate.
    /// * `to_default`: If true, makes this context the default context for the
    ///   target locality. If false, a new handle is generated for the context
    ///   even if the context was previously the default context.
    /// * `target_locality`: Indicates the target locality.
    ///
    /// # Errors
    ///
    /// * `[ErrCode::InvalidArgument`]: Returned if the handle is not found, the
    ///   target locality is not valid or allowed (a context cannot be moved to
    ///   a locality that supports encrypted sessions from one that does not),
    ///   or a target default context is already initialized.
    fn rotate_context_handle(
        &mut self,
        handle: Option<&ContextHandle>,
        to_default: bool,
        target_locality: LocalityId,
    ) -> DpeResult<Option<ContextHandle>>;

    /// Implements the DestroyContext DPE command. This command destroys the
    /// given context within the DPE and releases all associated resources.
    ///
    /// # Parameters
    ///
    /// * `handle`: The context to destroy.
    /// * `recursive`: Whether all previously derived contexts should also be
    ///   destroyed. If false, previously derived contexts will inherit the
    ///   parent of the destroyed context.
    ///
    /// # Errors
    ///
    /// * `[ErrCode::InvalidArgument`]: The handle is not found.
    fn destroy_context(
        &mut self,
        handle: Option<&ContextHandle>,
        recursive: bool,
    ) -> DpeResult<()>;
}

/// Handles a plaintext command message and provides a plaintext response.
///
/// Messages received via an encrypted session must be already decrypted and the
/// response provided here must be subsequently encrypted.
///
/// The `message_buffer` holds both command and response. Initially the buffer
/// must contain only the complete command message. On success, the command
/// message is cleared and the buffer is populated with a response message.
///
/// # Errors
///
/// If a command is unsuccessful an error is returned and the content of the
/// `message_buffer` is undefined and should be ignored and cleared before
/// reuse.
pub(crate) fn handle_command_message(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    let command_selector = decode_and_remove_command_header(message_buffer)?;
    debug!("Command id: {:?}", command_selector);
    let response = handle_command(dpe, command_selector, message_buffer)?;
    encode_and_insert_response_header(response)?;
    Ok(())
}

// Handles a command given a [`CommandSelector`] and input arguments.
//
// On input the message_buffer contains the encoded input arguments. On success
// the buffer is cleared and populated with encoded output arguments. Each
// handle_<command> function uses the buffer this way.
fn handle_command<'a>(
    dpe: &mut impl DpeCore,
    command_selector: CommandSelector,
    message_buffer: &'a mut Message,
) -> DpeResult<&'a mut Message> {
    match command_selector {
        CommandSelector::GetProfile => {
            handle_get_profile(dpe, message_buffer)?;
        }
        CommandSelector::OpenSession => {
            handle_open_session(dpe, message_buffer)?;
        }
        CommandSelector::CloseSession => {
            handle_close_session(dpe, message_buffer)?;
        }
        CommandSelector::SyncSession => {
            handle_sync_session(dpe, message_buffer)?;
        }
        CommandSelector::InitializeContext => {
            handle_initialize_context(dpe, message_buffer)?;
        }
        CommandSelector::DeriveContext => {
            handle_derive_context(dpe, message_buffer)?;
        }
        CommandSelector::GetCertificateChain => {
            handle_get_certificate_chain(dpe, message_buffer)?;
        }
        CommandSelector::CertifyKey => {
            handle_certify_key(dpe, message_buffer)?;
        }
        CommandSelector::Sign => {
            handle_sign(dpe, message_buffer)?;
        }
        CommandSelector::Seal => {
            handle_seal(dpe, message_buffer)?;
        }
        CommandSelector::Unseal => {
            handle_unseal(dpe, message_buffer)?;
        }
        CommandSelector::DeriveSealingPublicKey => {
            handle_derive_sealing_public_key(dpe, message_buffer)?;
        }
        CommandSelector::RotateContextHandle => {
            handle_rotate_context_handle(dpe, message_buffer)?;
        }
        CommandSelector::DestroyContext => {
            handle_destroy_context(dpe, message_buffer)?;
        }
    };
    Ok(message_buffer)
}

fn handle_get_profile(
    dpe: &impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const OUTPUT_ID_DESCRIPTOR: ArgId = 1;

    let _ = decode_args(message_buffer.as_slice(), &ArgTypeMap::new())?;

    let descriptor = dpe.get_profile()?;

    let mut output_args: ArgMap = Default::default();
    output_args.insert_or_err(OUTPUT_ID_DESCRIPTOR, &descriptor)?;
    encode_args(&output_args, message_buffer)
}

fn handle_open_session(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const INPUT_ID_HANDSHAKE: ArgId = 1;
    const OUTPUT_ID_HANDSHAKE: ArgId = 1;

    let input_arg_types =
        ArgTypeMap::from_iter([(INPUT_ID_HANDSHAKE, ArgTypeSelector::Bytes)]);
    let input_arg_map =
        decode_args(message_buffer.as_slice(), &input_arg_types)?;

    let initiator_handshake = input_arg_map.get_or_err(INPUT_ID_HANDSHAKE)?;
    let responder_handshake =
        dpe.open_session(&HandshakeMessage::from_slice(initiator_handshake)?)?;

    let mut output_args: ArgMap = Default::default();
    output_args.insert_or_err(OUTPUT_ID_HANDSHAKE, &responder_handshake)?;
    drop(input_arg_map);
    encode_args(&output_args, message_buffer)
}

fn handle_close_session(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    let _ = decode_args(message_buffer.as_slice(), &ArgTypeMap::new())?;
    dpe.close_session()?;
    encode_args(&Default::default(), message_buffer)
}

fn handle_sync_session(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const INPUT_ID_SESSION: ArgId = 1;
    const INPUT_ID_COUNTER: ArgId = 2;
    const OUTPUT_ID_COUNTER: ArgId = 1;

    let input_arg_types = ArgTypeMap::from_iter([
        (INPUT_ID_SESSION, ArgTypeSelector::Int),
        (INPUT_ID_COUNTER, ArgTypeSelector::Int),
    ]);
    let input_arg_map =
        decode_args(message_buffer.as_slice(), &input_arg_types)?;

    let target_session = SessionId(input_arg_map.get_or_err(INPUT_ID_SESSION)?);
    let in_counter = input_arg_map.get_or_err(INPUT_ID_COUNTER)?;
    let out_counter = dpe.sync_session(target_session, in_counter)?;
    let mut output_args: ArgMap = Default::default();
    output_args.insert_or_err(OUTPUT_ID_COUNTER, out_counter)?;
    drop(input_arg_map);
    encode_args(&output_args, message_buffer)
}

fn handle_initialize_context(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const INPUT_ID_SIMULATION: ArgId = 1;
    const INPUT_ID_USE_DEFAULT: ArgId = 2;
    const INPUT_ID_SEED: ArgId = 3;
    const OUTPUT_ID_HANDLE: ArgId = 1;

    let input_arg_types = ArgTypeMap::from_iter([
        (INPUT_ID_SIMULATION, ArgTypeSelector::Bool(false)),
        (INPUT_ID_USE_DEFAULT, ArgTypeSelector::Bool(false)),
        (INPUT_ID_SEED, ArgTypeSelector::Bytes),
    ]);
    let input_arg_map =
        decode_args(message_buffer.as_slice(), &input_arg_types)?;

    let simulation = input_arg_map.get_or_err(INPUT_ID_SIMULATION)?;
    let use_default = input_arg_map.get_or_err(INPUT_ID_USE_DEFAULT)?;
    let seed = input_arg_map.get_or_err(INPUT_ID_SEED)?;
    let handle = dpe.initialize_context(simulation, use_default, seed)?;
    let mut output_args: ArgMap = Default::default();
    if let Some(ref handle) = handle {
        output_args.insert_or_err(OUTPUT_ID_HANDLE, handle.as_slice())?;
    }
    drop(input_arg_map);
    encode_args(&output_args, message_buffer)
}

fn handle_derive_context(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const INPUT_ID_CONTEXT_HANDLE: ArgId = 1;
    const INPUT_ID_RETAIN_PARENT: ArgId = 2;
    const INPUT_ID_ALLOW_DERIVE: ArgId = 3;
    const INPUT_ID_CREATE_CERTIFICATE: ArgId = 4;
    const INPUT_ID_HANDSHAKE: ArgId = 5;
    const INPUT_ID_DICE_INPUT_DATA: ArgId = 6;
    const INPUT_ID_INTERNAL_INPUTS: ArgId = 7;
    const INPUT_ID_LOCALITY: ArgId = 8;
    const INPUT_ID_RETURN_CERTIFICATE: ArgId = 9;
    const INPUT_ID_ALLOW_EXPORT: ArgId = 10;
    const INPUT_ID_EXPORT: ArgId = 11;
    const INPUT_ID_RECURSIVE: ArgId = 12;
    const OUTPUT_ID_HANDLE: ArgId = 1;
    const OUTPUT_ID_HANDSHAKE: ArgId = 2;
    const OUTPUT_ID_PARENT_HANDLE: ArgId = 3;
    const OUTPUT_ID_CERTIFICATE: ArgId = 4;
    const OUTPUT_ID_EXPORTED_CDI: ArgId = 5;

    let input_arg_types = ArgTypeMap::from_iter([
        (INPUT_ID_CONTEXT_HANDLE, ArgTypeSelector::Bytes),
        (INPUT_ID_RETAIN_PARENT, ArgTypeSelector::Bool(false)),
        (INPUT_ID_ALLOW_DERIVE, ArgTypeSelector::Bool(true)),
        (INPUT_ID_CREATE_CERTIFICATE, ArgTypeSelector::Bool(true)),
        (INPUT_ID_HANDSHAKE, ArgTypeSelector::Bytes),
        (INPUT_ID_DICE_INPUT_DATA, ArgTypeSelector::Bytes),
        (INPUT_ID_INTERNAL_INPUTS, ArgTypeSelector::Other),
        (INPUT_ID_LOCALITY, ArgTypeSelector::Bytes),
        (INPUT_ID_RETURN_CERTIFICATE, ArgTypeSelector::Bool(false)),
        (INPUT_ID_ALLOW_EXPORT, ArgTypeSelector::Bool(false)),
        (INPUT_ID_EXPORT, ArgTypeSelector::Bool(false)),
        (INPUT_ID_RECURSIVE, ArgTypeSelector::Bool(false)),
    ]);

    let input_arg_map =
        decode_args(message_buffer.as_slice(), &input_arg_types)?;

    let context_handle = ContextHandle::from_slice_to_option(
        input_arg_map.get_or_err(INPUT_ID_CONTEXT_HANDLE)?,
    )?;
    let handshake = HandshakeMessage::from_slice(
        input_arg_map.get_or_err(INPUT_ID_HANDSHAKE)?,
    )?;
    let encoded_dice_input =
        input_arg_map.get_or_err(INPUT_ID_DICE_INPUT_DATA)?;
    let internal_inputs_vec = decode_internal_inputs(
        input_arg_map.get_or_err(INPUT_ID_INTERNAL_INPUTS)?,
    )?;
    let locality = decode_locality(
        input_arg_map.get_or_err(INPUT_ID_LOCALITY)?,
        dpe.get_current_locality(),
    )?;
    let options = DeriveContextOptions {
        retain_parent_context: input_arg_map
            .get_or_err(INPUT_ID_RETAIN_PARENT)?,
        allow_new_context_to_derive: input_arg_map
            .get_or_err(INPUT_ID_ALLOW_DERIVE)?,
        create_certificate: input_arg_map
            .get_or_err(INPUT_ID_CREATE_CERTIFICATE)?,
        return_certificate: input_arg_map
            .get_or_err(INPUT_ID_RETURN_CERTIFICATE)?,
        allow_new_context_to_export: input_arg_map
            .get_or_err(INPUT_ID_ALLOW_EXPORT)?,
        export_cdi: input_arg_map.get_or_err(INPUT_ID_EXPORT)?,
        recursive: input_arg_map.get_or_err(INPUT_ID_RECURSIVE)?,
    };
    let (version_info, dice_input) = decode_dice_input(encoded_dice_input)?;
    let (
        new_context_handle,
        handshake_out,
        parent_handle,
        new_certificate,
        exported_cdi,
    ) = dpe.derive_context(
        &options,
        context_handle.as_ref(),
        if !handshake.is_empty() { Some(&handshake) } else { None },
        version_info,
        &dice_input,
        internal_inputs_vec.as_slice(),
        locality,
    )?;
    let mut output_args: ArgMap = Default::default();
    if let Some(ref new_context_handle) = new_context_handle {
        output_args
            .insert_or_err(OUTPUT_ID_HANDLE, new_context_handle.as_slice())?;
    }
    if let Some(ref handshake_out) = handshake_out {
        output_args.insert_or_err(OUTPUT_ID_HANDSHAKE, handshake_out)?;
    }
    if let Some(ref parent_handle) = parent_handle {
        output_args
            .insert_or_err(OUTPUT_ID_PARENT_HANDLE, parent_handle.as_slice())?;
    }
    if let Some(ref new_certificate) = new_certificate {
        output_args.insert_or_err(
            OUTPUT_ID_CERTIFICATE,
            new_certificate.0.as_slice(),
        )?;
    }
    if let Some(ref exported_cdi) = exported_cdi {
        output_args.insert_or_err(OUTPUT_ID_EXPORTED_CDI, exported_cdi)?;
    }
    drop(input_arg_map);
    encode_args(&output_args, message_buffer)
}

fn handle_get_certificate_chain(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const INPUT_ID_CONTEXT_HANDLE: ArgId = 1;
    const INPUT_ID_RETAIN_CONTEXT: ArgId = 2;
    const INPUT_ID_CLEAR_FROM_CONTEXT: ArgId = 3;
    const OUTPUT_ID_CERTIFICATE_CHAIN: ArgId = 1;
    const OUTPUT_ID_HANDLE: ArgId = 2;

    let input_arg_types = ArgTypeMap::from_iter([
        (INPUT_ID_CONTEXT_HANDLE, ArgTypeSelector::Bytes),
        (INPUT_ID_RETAIN_CONTEXT, ArgTypeSelector::Bool(false)),
        (INPUT_ID_CLEAR_FROM_CONTEXT, ArgTypeSelector::Bool(false)),
    ]);

    let input_arg_map =
        decode_args(message_buffer.as_slice(), &input_arg_types)?;

    let context_handle = ContextHandle::from_slice_to_option(
        input_arg_map.get_or_err(INPUT_ID_CONTEXT_HANDLE)?,
    )?;
    let retain_context = input_arg_map.get_or_err(INPUT_ID_RETAIN_CONTEXT)?;
    let clear_from_context =
        input_arg_map.get_or_err(INPUT_ID_CLEAR_FROM_CONTEXT)?;
    let (certificate_chain, new_context_handle) = dpe.get_certificate_chain(
        context_handle.as_ref(),
        retain_context,
        clear_from_context,
    )?;
    let mut output_args: ArgMap = Default::default();
    output_args.insert_or_err(
        OUTPUT_ID_CERTIFICATE_CHAIN,
        certificate_chain.as_slice(),
    )?;
    if let Some(ref new_context_handle) = new_context_handle {
        output_args
            .insert_or_err(OUTPUT_ID_HANDLE, new_context_handle.as_slice())?;
    }
    drop(input_arg_map);
    encode_args(&output_args, message_buffer)
}

fn handle_certify_key(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const INPUT_ID_CONTEXT_HANDLE: ArgId = 1;
    const INPUT_ID_RETAIN_CONTEXT: ArgId = 2;
    const INPUT_ID_PUBLIC_KEY: ArgId = 3;
    const INPUT_ID_LABEL: ArgId = 4;
    const INPUT_ID_ADDITIONAL_INPUT: ArgId = 6;
    const OUTPUT_ID_CERTIFICATE: ArgId = 1;
    const OUTPUT_ID_DERIVED_PUBLIC_KEY: ArgId = 2;
    const OUTPUT_ID_HANDLE: ArgId = 3;

    let input_arg_types = ArgTypeMap::from_iter([
        (INPUT_ID_CONTEXT_HANDLE, ArgTypeSelector::Bytes),
        (INPUT_ID_RETAIN_CONTEXT, ArgTypeSelector::Bool(false)),
        (INPUT_ID_PUBLIC_KEY, ArgTypeSelector::Bytes),
        (INPUT_ID_LABEL, ArgTypeSelector::Bytes),
        (INPUT_ID_ADDITIONAL_INPUT, ArgTypeSelector::Bytes),
    ]);

    let input_arg_map =
        decode_args(message_buffer.as_slice(), &input_arg_types)?;

    let context_handle = ContextHandle::from_slice_to_option(
        input_arg_map.get_or_err(INPUT_ID_CONTEXT_HANDLE)?,
    )?;
    let retain_context = input_arg_map.get_or_err(INPUT_ID_RETAIN_CONTEXT)?;
    let public_key_bytes: &[u8] =
        input_arg_map.get_or_err(INPUT_ID_PUBLIC_KEY)?;
    let public_key;
    let public_key_opt = if public_key_bytes.is_empty() {
        None
    } else {
        public_key = SigningPublicKey::from_slice(public_key_bytes)?;
        Some(&public_key)
    };
    let label = input_arg_map.get_or_err(INPUT_ID_LABEL)?;
    let additional_input =
        input_arg_map.get_or_err(INPUT_ID_ADDITIONAL_INPUT)?;
    let (certificate, derived_public_key, new_context_handle) = dpe
        .certify_key(
            context_handle.as_ref(),
            retain_context,
            public_key_opt,
            label,
            additional_input,
        )?;
    let mut output_args: ArgMap = Default::default();
    output_args
        .insert_or_err(OUTPUT_ID_CERTIFICATE, certificate.0.as_slice())?;
    if let Some(ref derived_public_key) = derived_public_key {
        output_args.insert_or_err(
            OUTPUT_ID_DERIVED_PUBLIC_KEY,
            derived_public_key.as_slice(),
        )?;
    }
    if let Some(ref new_context_handle) = new_context_handle {
        output_args
            .insert_or_err(OUTPUT_ID_HANDLE, new_context_handle.as_slice())?;
    }
    drop(input_arg_map);
    encode_args(&output_args, message_buffer)
}

fn handle_sign(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const INPUT_ID_CONTEXT_HANDLE: ArgId = 1;
    const INPUT_ID_RETAIN_CONTEXT: ArgId = 2;
    const INPUT_ID_LABEL: ArgId = 3;
    const INPUT_ID_IS_SYMMETRIC: ArgId = 4;
    const INPUT_ID_TO_BE_SIGNED: ArgId = 5;
    const OUTPUT_ID_SIGNATURE: ArgId = 1;
    const OUTPUT_ID_HANDLE: ArgId = 2;

    let input_arg_types = ArgTypeMap::from_iter([
        (INPUT_ID_CONTEXT_HANDLE, ArgTypeSelector::Bytes),
        (INPUT_ID_RETAIN_CONTEXT, ArgTypeSelector::Bool(false)),
        (INPUT_ID_LABEL, ArgTypeSelector::Bytes),
        (INPUT_ID_IS_SYMMETRIC, ArgTypeSelector::Bool(false)),
        (INPUT_ID_TO_BE_SIGNED, ArgTypeSelector::Bytes),
    ]);

    let input_arg_map =
        decode_args(message_buffer.as_slice(), &input_arg_types)?;

    let context_handle = ContextHandle::from_slice_to_option(
        input_arg_map.get_or_err(INPUT_ID_CONTEXT_HANDLE)?,
    )?;
    let retain_context = input_arg_map.get_or_err(INPUT_ID_RETAIN_CONTEXT)?;
    let label = input_arg_map.get_or_err(INPUT_ID_LABEL)?;
    let is_symmetric = input_arg_map.get_or_err(INPUT_ID_IS_SYMMETRIC)?;
    let to_be_signed = input_arg_map.get_or_err(INPUT_ID_TO_BE_SIGNED)?;
    let (signature, new_context_handle) = dpe.sign(
        context_handle.as_ref(),
        retain_context,
        label,
        is_symmetric,
        to_be_signed,
    )?;
    let mut output_args: ArgMap = Default::default();
    output_args.insert_or_err(OUTPUT_ID_SIGNATURE, signature.as_slice())?;
    if let Some(ref new_context_handle) = new_context_handle {
        output_args
            .insert_or_err(OUTPUT_ID_HANDLE, new_context_handle.as_slice())?;
    }
    drop(input_arg_map);
    encode_args(&output_args, message_buffer)
}

fn handle_seal(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const INPUT_ID_CONTEXT_HANDLE: ArgId = 1;
    const INPUT_ID_RETAIN_CONTEXT: ArgId = 2;
    const INPUT_ID_POLICY: ArgId = 3;
    const INPUT_ID_LABEL: ArgId = 4;
    const INPUT_ID_DATA_TO_SEAL: ArgId = 5;
    const OUTPUT_ID_SEALED_DATA: ArgId = 1;
    const OUTPUT_ID_HANDLE: ArgId = 2;

    let input_arg_types = ArgTypeMap::from_iter([
        (INPUT_ID_CONTEXT_HANDLE, ArgTypeSelector::Bytes),
        (INPUT_ID_RETAIN_CONTEXT, ArgTypeSelector::Bool(false)),
        (INPUT_ID_POLICY, ArgTypeSelector::Bytes),
        (INPUT_ID_LABEL, ArgTypeSelector::Bytes),
        (INPUT_ID_DATA_TO_SEAL, ArgTypeSelector::Bytes),
    ]);

    let input_arg_map =
        decode_args(message_buffer.as_slice(), &input_arg_types)?;

    let context_handle = ContextHandle::from_slice_to_option(
        input_arg_map.get_or_err(INPUT_ID_CONTEXT_HANDLE)?,
    )?;
    let retain_context = input_arg_map.get_or_err(INPUT_ID_RETAIN_CONTEXT)?;
    let policy = input_arg_map.get_or_err(INPUT_ID_POLICY)?;
    let label = input_arg_map.get_or_err(INPUT_ID_LABEL)?;
    let data_to_seal = input_arg_map.get_or_err(INPUT_ID_DATA_TO_SEAL)?;
    let (sealed_data, new_context_handle) = dpe.seal(
        context_handle.as_ref(),
        retain_context,
        policy,
        label,
        data_to_seal,
    )?;
    let mut output_args: ArgMap = Default::default();
    output_args.insert_or_err(OUTPUT_ID_SEALED_DATA, sealed_data.as_slice())?;
    if let Some(ref new_context_handle) = new_context_handle {
        output_args
            .insert_or_err(OUTPUT_ID_HANDLE, new_context_handle.as_slice())?;
    }
    drop(input_arg_map);
    encode_args(&output_args, message_buffer)
}

fn handle_unseal(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const INPUT_ID_CONTEXT_HANDLE: ArgId = 1;
    const INPUT_ID_RETAIN_CONTEXT: ArgId = 2;
    const INPUT_ID_IS_ASYMMETRIC: ArgId = 3;
    const INPUT_ID_POLICY: ArgId = 4;
    const INPUT_ID_LABEL: ArgId = 5;
    const INPUT_ID_DATA_TO_UNSEAL: ArgId = 6;
    const OUTPUT_ID_UNSEALED_DATA: ArgId = 1;
    const OUTPUT_ID_HANDLE: ArgId = 2;

    let input_arg_types = ArgTypeMap::from_iter([
        (INPUT_ID_CONTEXT_HANDLE, ArgTypeSelector::Bytes),
        (INPUT_ID_RETAIN_CONTEXT, ArgTypeSelector::Bool(false)),
        (INPUT_ID_IS_ASYMMETRIC, ArgTypeSelector::Bool(false)),
        (INPUT_ID_POLICY, ArgTypeSelector::Bytes),
        (INPUT_ID_LABEL, ArgTypeSelector::Bytes),
        (INPUT_ID_DATA_TO_UNSEAL, ArgTypeSelector::Bytes),
    ]);

    let input_arg_map =
        decode_args(message_buffer.as_slice(), &input_arg_types)?;

    let context_handle = ContextHandle::from_slice_to_option(
        input_arg_map.get_or_err(INPUT_ID_CONTEXT_HANDLE)?,
    )?;
    let retain_context = input_arg_map.get_or_err(INPUT_ID_RETAIN_CONTEXT)?;
    let is_asymmetric = input_arg_map.get_or_err(INPUT_ID_IS_ASYMMETRIC)?;
    let policy = input_arg_map.get_or_err(INPUT_ID_POLICY)?;
    let label = input_arg_map.get_or_err(INPUT_ID_LABEL)?;
    let data_to_unseal = input_arg_map.get_or_err(INPUT_ID_DATA_TO_UNSEAL)?;
    let (unsealed_data, new_context_handle) = dpe.unseal(
        context_handle.as_ref(),
        retain_context,
        is_asymmetric,
        policy,
        label,
        data_to_unseal,
    )?;
    let mut output_args: ArgMap = Default::default();
    output_args
        .insert_or_err(OUTPUT_ID_UNSEALED_DATA, unsealed_data.as_slice())?;
    if let Some(ref new_context_handle) = new_context_handle {
        output_args
            .insert_or_err(OUTPUT_ID_HANDLE, new_context_handle.as_slice())?;
    }
    drop(input_arg_map);
    encode_args(&output_args, message_buffer)
}

fn handle_derive_sealing_public_key(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const INPUT_ID_CONTEXT_HANDLE: ArgId = 1;
    const INPUT_ID_RETAIN_CONTEXT: ArgId = 2;
    const INPUT_ID_POLICY: ArgId = 3;
    const INPUT_ID_LABEL: ArgId = 4;
    const OUTPUT_ID_PUBLIC_KEY: ArgId = 1;
    const OUTPUT_ID_HANDLE: ArgId = 2;

    let input_arg_types = ArgTypeMap::from_iter([
        (INPUT_ID_CONTEXT_HANDLE, ArgTypeSelector::Bytes),
        (INPUT_ID_RETAIN_CONTEXT, ArgTypeSelector::Bool(false)),
        (INPUT_ID_POLICY, ArgTypeSelector::Bytes),
        (INPUT_ID_LABEL, ArgTypeSelector::Bytes),
    ]);

    let input_arg_map =
        decode_args(message_buffer.as_slice(), &input_arg_types)?;

    let context_handle = ContextHandle::from_slice_to_option(
        input_arg_map.get_or_err(INPUT_ID_CONTEXT_HANDLE)?,
    )?;
    let retain_context = input_arg_map.get_or_err(INPUT_ID_RETAIN_CONTEXT)?;
    let policy = input_arg_map.get_or_err(INPUT_ID_POLICY)?;
    let label = input_arg_map.get_or_err(INPUT_ID_LABEL)?;
    let (public_key, new_context_handle) = dpe.derive_sealing_public_key(
        context_handle.as_ref(),
        retain_context,
        policy,
        label,
    )?;
    let mut output_args: ArgMap = Default::default();
    output_args.insert_or_err(OUTPUT_ID_PUBLIC_KEY, public_key.as_slice())?;
    if let Some(ref new_context_handle) = new_context_handle {
        output_args
            .insert_or_err(OUTPUT_ID_HANDLE, new_context_handle.as_slice())?;
    }
    drop(input_arg_map);
    encode_args(&output_args, message_buffer)
}

fn handle_rotate_context_handle(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const INPUT_ID_HANDLE: ArgId = 1;
    const INPUT_ID_TO_DEFAULT: ArgId = 2;
    const INPUT_ID_TARGET_LOCALITY: ArgId = 3;
    const OUTPUT_ID_HANDLE: ArgId = 1;

    let input_arg_types = ArgTypeMap::from_iter([
        (INPUT_ID_HANDLE, ArgTypeSelector::Bytes),
        (INPUT_ID_TO_DEFAULT, ArgTypeSelector::Bool(false)),
        (INPUT_ID_TARGET_LOCALITY, ArgTypeSelector::Bytes),
    ]);

    let input_arg_map =
        decode_args(message_buffer.as_slice(), &input_arg_types)?;

    let handle = ContextHandle::from_slice_to_option(
        input_arg_map.get_or_err(INPUT_ID_HANDLE)?,
    )?;
    let to_default = input_arg_map.get_or_err(INPUT_ID_TO_DEFAULT)?;
    let target_locality = decode_locality(
        input_arg_map.get_or_err(INPUT_ID_TARGET_LOCALITY)?,
        dpe.get_current_locality(),
    )?;
    let new_handle = dpe.rotate_context_handle(
        handle.as_ref(),
        to_default,
        target_locality,
    )?;
    let mut output_args: ArgMap = Default::default();
    if let Some(ref new_handle) = new_handle {
        output_args.insert_or_err(OUTPUT_ID_HANDLE, new_handle.as_slice())?;
    }
    drop(input_arg_map);
    encode_args(&output_args, message_buffer)
}

fn handle_destroy_context(
    dpe: &mut impl DpeCore,
    message_buffer: &mut Message,
) -> DpeResult<()> {
    const INPUT_ID_HANDLE: ArgId = 1;
    const INPUT_ID_RECURSIVE: ArgId = 2;

    let input_arg_types = ArgTypeMap::from_iter([
        (INPUT_ID_HANDLE, ArgTypeSelector::Bytes),
        (INPUT_ID_RECURSIVE, ArgTypeSelector::Bool(false)),
    ]);

    let input_arg_map =
        decode_args(message_buffer.as_slice(), &input_arg_types)?;

    let handle = ContextHandle::from_slice_to_option(
        input_arg_map.get_or_err(INPUT_ID_HANDLE)?,
    )?;
    let recursive = input_arg_map.get_or_err(INPUT_ID_RECURSIVE)?;
    dpe.destroy_context(handle.as_ref(), recursive)?;
    drop(input_arg_map);
    message_buffer.clear();
    encode_args(&Default::default(), message_buffer)
}