dcrypt-api 1.2.3

Public API traits and types for the dcrypt library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Validation utilities for cryptographic operations

use super::types::{Error, Result};

/// Validate a parameter condition
pub fn parameter<T>(condition: bool, context: &'static str, reason: &'static str) -> Result<T>
where
    T: Default,
{
    if !condition {
        return Err(Error::InvalidParameter {
            context,
            #[cfg(feature = "std")]
            message: reason.to_string(),
        });
    }
    Ok(T::default())
}

/// Just check a parameter condition
pub fn check_parameter(condition: bool, context: &'static str, reason: &'static str) -> Result<()> {
    if !condition {
        return Err(Error::InvalidParameter {
            context,
            #[cfg(feature = "std")]
            message: reason.to_string(),
        });
    }
    Ok(())
}

/// Validate an exact length
pub fn length(context: &'static str, actual: usize, expected: usize) -> Result<()> {
    if actual != expected {
        return Err(Error::InvalidLength {
            context,
            expected,
            actual,
        });
    }
    Ok(())
}

/// Validate a minimum length
pub fn min_length(context: &'static str, actual: usize, min: usize) -> Result<()> {
    if actual < min {
        return Err(Error::InvalidLength {
            context,
            expected: min,
            actual,
        });
    }
    Ok(())
}

/// Validate a maximum length
pub fn max_length(context: &'static str, actual: usize, max: usize) -> Result<()> {
    if actual > max {
        return Err(Error::InvalidLength {
            context,
            expected: max,
            actual,
        });
    }
    Ok(())
}

/// Validate length is within range (inclusive)
pub fn range_length(context: &'static str, actual: usize, min: usize, max: usize) -> Result<()> {
    if actual < min || actual > max {
        return Err(Error::InvalidParameter {
            context,
            #[cfg(feature = "std")]
            message: format!("length must be between {} and {}", min, max),
        });
    }
    Ok(())
}

/// Validate authentication result
pub fn authentication(is_valid: bool, context: &'static str) -> Result<()> {
    if !is_valid {
        return Err(Error::AuthenticationFailed {
            context,
            #[cfg(feature = "std")]
            message: "authentication failed".to_string(),
        });
    }
    Ok(())
}

/// Validate key format or content
pub fn key(is_valid: bool, context: &'static str, reason: &'static str) -> Result<()> {
    if !is_valid {
        return Err(Error::InvalidKey {
            context,
            #[cfg(feature = "std")]
            message: reason.to_string(),
        });
    }
    Ok(())
}

/// Validate signature format or content
pub fn signature(is_valid: bool, context: &'static str, reason: &'static str) -> Result<()> {
    if !is_valid {
        return Err(Error::InvalidSignature {
            context,
            #[cfg(feature = "std")]
            message: reason.to_string(),
        });
    }
    Ok(())
}

/// Validate ciphertext format or content
pub fn ciphertext(is_valid: bool, context: &'static str, reason: &'static str) -> Result<()> {
    if !is_valid {
        return Err(Error::InvalidCiphertext {
            context,
            #[cfg(feature = "std")]
            message: reason.to_string(),
        });
    }
    Ok(())
}

/// Create a not implemented error
pub fn not_implemented(feature: &'static str) -> Error {
    Error::NotImplemented { feature }
}