Enum ParsePasswordError

#[non_exhaustive]
pub enum ParsePasswordError {
    TooShort {
        value: usize,
        required: usize,
    },
    LittleEntropy {
        value: u64,
        required: u64,
    },
}

This is a compromise. Generally we want to be wordlist-agnostic here. But we can’t ignore that the PGP wordlist is the most common wordlist in use.

• The shortest word in the PGP wordlist is 4 characters long. The longest word is 9 characters. This means we can’t limit to more than 9 bytes here, ‘solo-orca’ is 9 bytes, and we want to allow 2-word codes.
• A 9 character random password is very strong. If it is only comprised of uniformly distributed lowercase ASCII characters, we have an entropy of 26^9 >= 40 bits. This is much more than the default 16 bits we get from two words from the PGP wordlist.
• An emoji contains at least 2 bytes of data. So two emoji are actually about the same security as two words from the PGP wordlist.

We ultimately can’t protect people from making bad choices, as entropy is a very difficult thing. What we can do instead is offer guidance, by printing warnings in case of rather short passwords, and making people choose for themselves whether their privacy is worth it to them choosing longer codes.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

TooShort

Password too short

Fields

value: usize

The calculated value

required: usize

The value that is required

LittleEntropy

Password does not have enough entropy

Fields

value: u64

The calculated value

required: u64

The value that is required

Trait Implementations

impl Clone for ParsePasswordError

fn clone(&self) -> ParsePasswordError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParsePasswordError

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

Formats the value using the given formatter.

impl Display for ParsePasswordError

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

Formats the value using the given formatter.

impl Error for ParsePasswordError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<ParsePasswordError> for ParseCodeError

fn from(source: ParsePasswordError) -> Self

Converts to this type from the input type.

impl Ord for ParsePasswordError

fn cmp(&self, other: &ParsePasswordError) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ParsePasswordError

fn eq(&self, other: &ParsePasswordError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for ParsePasswordError

fn partial_cmp(&self, other: &ParsePasswordError) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for ParsePasswordError

impl Eq for ParsePasswordError

impl StructuralPartialEq for ParsePasswordError