Struct smart_config::de::Secret

pub struct Secret<De>(pub De);

Deserializer for arbitrary secret params. Will set the corresponding flag for ParamMetadata, making raw param value hidden in the debug output etc.

Can be used by placing #[serde(secret)] on the param.

Important. The deserializer does not hide the deserialized value of the param! You are responsible for doing it by selecting an appropriate param type (e.g., one that zeroizes its contents on drop).

Examples

use secrecy::{ExposeSecret, ExposeSecretMut, SecretBox};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use smart_config::{de::Serde, testing, DescribeConfig, DeserializeConfig};

// It is generally a good idea to wrap a secret into a `SecretBox`
// so that it is zeroized on drop and has an opaque `Debug` representation.
#[derive(Debug)]
struct NumSecret(SecretBox<u64>);

impl Serialize for NumSecret {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        // Serialize the underlying secret
        self.0.expose_secret().serialize(serializer)
    }
}

impl<'de> serde::Deserialize<'de> for NumSecret {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        // Deserialize a `u64` and wrap it into a secret.
        let mut secret = SecretBox::default();
        *secret.expose_secret_mut() = u64::deserialize(deserializer)?;
        Ok(Self(secret))
    }
}

#[derive(DescribeConfig, DeserializeConfig)]
struct TestConfig {
    // Secret values must be deserializable from a string
    // because all secrets are strings. Because of type coercion, a `u64` deserializer
    // will work correctly if supplied with a string, which we express
    // through `Serde![]` args.
    #[config(secret, with = Serde![int, str])]
    secret: NumSecret,
}

let input = smart_config::config!("secret": "123");
let config: TestConfig = testing::test(input)?;
assert_eq!(*config.secret.0.expose_secret(), 123);

Tuple Fields

0: De

Trait Implementations

impl<De: Debug> Debug for Secret<De>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, De> DeserializeParam<T> for Secret<De>

where De: DeserializeParam<T>,

const EXPECTING: BasicTypes = _

Describes which parameter this deserializer is expecting.

fn describe(&self, description: &mut TypeDescription)

Additional info about the deserialized type, e.g., extended description.

fn deserialize_param( &self, ctx: DeserializeContext<'_>, param: &'static ParamMetadata, ) -> Result<T, ErrorWithOrigin>

Performs deserialization given the context and param metadata.

fn serialize_param(&self, param: &T) -> Value

Serializes the provided parameter to the JSON model.