Struct UntrustedValue 

pub struct UntrustedValue<Insecure> { /* private fields */ }

Represents an untrusted/untrustworthy value. The data contained inside this type is called tainted.

An attacker might be able to control (part) of the returned value. Take special care processing this data.

Taint can be cleared by using one of the traits SanitizeWith or SanitizeValue. Effectively, sanitizing the data.

This type does explicitly not implement common traits like Debug, Display, etc. since the data contained is considered untrusted. If desired you COULD implement these traits in for your custom types.

For naming purposes an untrusted value mapped inside this type is considered safe/trusted since it can not be accessed without sanitization.

Implementations

impl<Insecure> UntrustedValue<Insecure>

Implementation of the UntrustedValue type.

pub fn use_untrusted_value(self) -> Insecure

Be sure that you carefully handle the returned value since it may be controllable by a malicious actor.

Does not perform any sanitization on the returned value.

Examples found in repository

examples/untrusted_inputs_nested_structs.rs (line 35)

    fn sanitize_value(self) -> Result<NetworkConfig, Self::Error> {
        Ok(NetworkConfig {
            port: self.port.use_untrusted_value(),
            listen_address: self.listen_address.use_untrusted_value(),
        }) // in real application: do some sanitizing
    }

pub fn wrap(value: Insecure) -> Self

Wraps the provided value as UntrustedValue

Examples found in repository

examples/untrusted_outputs.rs (line 18)

fn main() {
    // call library function
    assert_eq!(
        some_lib_func().type_id(),
        UntrustedValue::wrap("test".to_string()).type_id()
    );
}

Trait Implementations

impl<Insecure: Clone> Clone for UntrustedValue<Insecure>

A tainted value may be cloned if the underlying value is cloneable. This is considered safe since the taint is also cloned.

fn clone(&self) -> Self

Clones the value

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Insecure: Copy> Copy for UntrustedValue<Insecure>

impl<Insecure> From<Insecure> for UntrustedValue<Insecure>

Provide easy conversion from some value to an UntrustedValue.

fn from(value: Insecure) -> Self

Wraps the provided value as UntrustedValue

impl<Insecure, Trusted> From<UntrustedValue<Insecure>> for MaybeUntrusted<Insecure, Trusted>

fn from(value: UntrustedValue<Insecure>) -> Self

Converts an UntrustedValue to a MaybeUntrusted value

impl<Sanitized, E, Insecure: SanitizeValue<Sanitized, Error = E>> SanitizeValue<Sanitized> for UntrustedValue<Insecure>

If the tainted data type can be sanitized using the SanitizeValue trait, implement also the SanitizeValue trait for this UntrustedValue type.

type Error = E

The error type will be propagated from the underlying SanitizeValue implementation.

fn sanitize_value(self) -> Result<Sanitized, Self::Error>

Sanitizes the value.

The returned value is sanitized and can be safely used. If the value cannot be sanitized, an error must be returned.

impl<Insecure, Trusted> SanitizeWith<Insecure, Trusted> for UntrustedValue<Insecure>

Taint can be cleared from the value by using a sanitizer. Effectively unpacking the value; passing it to the sanitizer and returning the result.

fn sanitize_with<Sanitizer, Error>( self, sanitizer: Sanitizer, ) -> Result<Trusted, Error>

where Sanitizer: FnOnce(Insecure) -> Result<Trusted, Error>,

Sanitizes the value using the provided sanitizer.

The sanitizer may transmute the value to a different type. If sanitization fails, an error must be returned.