mykey 1.0.0

MIKEY (RFC 3830) — Multimedia Internet KEYing for SRTP key exchange
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

//! Error types returned by mykey.

use thiserror::Error;

/// All errors that mykey operations can produce.
#[derive(Debug, Error)]
pub enum MikeyError {
    /// The MIKEY version byte was not `1`.
    #[error("invalid MIKEY version: {0}")]
    InvalidVersion(u8),

    /// The data type byte does not correspond to a known MIKEY message type.
    #[error("unsupported data type: {0}")]
    UnsupportedDataType(u8),

    /// The key exchange method byte is not recognized.
    #[error("unsupported key exchange method: {0}")]
    UnsupportedKeyExchange(u8),

    /// A payload type byte is outside the set of known types.
    #[error("invalid payload type: {0}")]
    InvalidPayloadType(u8),

    /// The message buffer is shorter than the minimum required length.
    #[error("message too short: expected at least {expected} bytes, got {actual}")]
    MessageTooShort {
        /// Minimum expected byte count.
        expected: usize,
        /// Actual byte count received.
        actual: usize,
    },

    /// HMAC-SHA-1-160 verification failed (wrong PSK or tampered message).
    #[error("invalid MAC: verification failed")]
    InvalidMac,

    /// The DH value bytes are not a valid X25519 public key.
    #[error("invalid DH value")]
    InvalidDhValue,

    /// A payload required by the operation was absent from the message.
    #[error("missing required payload: {0}")]
    MissingPayload(&'static str),

    /// A low-level cryptographic operation failed.
    #[error("crypto error: {0}")]
    Crypto(String),

    /// The DH public key received from a peer did not match the pinned key.
    #[error("peer key mismatch for '{peer}': expected {expected}, received {received}")]
    PeerKeyMismatch {
        /// Name of the expected peer.
        peer: String,
        /// Hex-encoded expected public key.
        expected: String,
        /// Hex-encoded received public key.
        received: String,
    },

    /// Wire-format parsing failed.
    #[error("parse error: {0}")]
    Parse(String),
}

/// Convenience alias for `Result<T, MikeyError>`.
pub type Result<T> = std::result::Result<T, MikeyError>;