packet_parser 1.3.0

A powerful and modular Rust crate for network packet parsing.
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
132
133
134
135
136
137
138
139
140
141
142

// Copyright (c) 2024 Cyprien Avico avicocyprien@yahoo.com
//
// Licensed under the MIT License <LICENSE-MIT or http://opensource.org/licenses/MIT>.
// This file may not be copied, modified, or distributed except according to those terms.

//! The `Oui` module provides a representation of Organizationally Unique Identifiers (OUI).
//! An OUI is the first 3 bytes of a MAC address, used to identify the manufacturer of a device.
//!
//! # Overview
//!
//! The `Oui` enum represents known manufacturers based on their OUI values.
//! The `from_bytes` method attempts to match the first three bytes of a MAC address
//! to a known manufacturer.
//!
//! # Example
//!
//! ```rust
//! use packet_parser::parse::data_link::mac_addres::oui::Oui;
//!
//! let oui = Oui::from_bytes(&[0x2C, 0xFD, 0xA1, 0x12, 0x34, 0x56]);
//! assert_eq!(oui, Oui::ASUSTek);
//!
//! let unknown_oui = Oui::from_bytes(&[0x00, 0x11, 0x22, 0x33, 0x44, 0x55]);
//! assert_eq!(unknown_oui, Oui::Unknown);
//! ```
//!
//! # Supported Manufacturers
//!
//! The following OUI values are recognized:
//!
//! | OUI Prefix      | Manufacturer |
//! |----------------|-------------|
//! | `2C:FD:A1`     | ASUSTek     |
//! | `E0:DC:A0`     | Siemens     |
//! | `B0:5B:99`     | Sagemcom    |
//! | `64:6E:E0`     | Intel Corporate |
//!
//! Any unrecognized OUI will be labeled as `Unknown`.

/// Represents an Organizationally Unique Identifier (OUI).
#[derive(Debug, PartialEq, Eq)]
pub enum Oui {
    /// ASUSTek Computer Inc.
    ASUSTek,
    /// Siemens AG.
    Siemens,

    SiemensN,

    SiemensD3,

    PnMc,
    /// Sagemcom Broadband SAS.
    Sagemcom,
    /// Intel Corporate.
    Intel,
    /// Unknown manufacturer.
    Unknown,
}

impl Oui {
    /// Creates a `Oui` instance from a MAC address byte slice.
    ///
    /// The method checks the first three bytes of the given slice to determine the manufacturer.
    /// If the OUI is not recognized, it returns `Oui::Unknown`.
    ///
    /// # Parameters
    ///
    /// - `bytes`: A slice of at least three bytes representing the MAC address.
    ///
    /// # Returns
    ///
    /// - `Oui::ASUSTek` for `2C:FD:A1`
    /// - `Oui::Siemens` for `E0:DC:A0`
    /// - `Oui::Sagemcom` for `B0:5B:99`
    /// - `Oui::Intel` for `64:6E:E0`
    /// - `Oui::Unknown` for any unrecognized prefix
    ///
    /// # Example
    ///
    /// ```
    /// use packet_parser::parse::data_link::mac_addres::oui::Oui;
    ///
    /// let oui = Oui::from_bytes(&[0x64, 0x6E, 0xE0, 0x12, 0x34, 0x56]);
    /// assert_eq!(oui, Oui::Intel);
    ///
    /// let unknown_oui = Oui::from_bytes(&[0x00, 0x11, 0x22, 0x33, 0x44, 0x55]);
    /// assert_eq!(unknown_oui, Oui::Unknown);
    /// ```
    pub fn from_bytes(bytes: &[u8]) -> Self {
        match bytes {
            [0x2C, 0xFD, 0xA1, ..] => Oui::ASUSTek,
            [0xE0, 0xDC, 0xA0, ..] => Oui::Siemens,
            [0x08, 0x00, 0x06, ..] => Oui::SiemensN,
            [0xB0, 0x5B, 0x99, ..] => Oui::Sagemcom,
            [0x64, 0x6E, 0xE0, ..] => Oui::Intel, // Ajout de Intel Corporate
            [0x01, 0x0E, 0xCF, ..] => Oui::PnMc,
            [0x00, 0x0E, 0x8C, ..] => Oui::SiemensD3,
            _ => Oui::Unknown,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_oui_asustek() {
        let bytes = [0x2C, 0xFD, 0xA1, 0x12, 0x34, 0x56];
        let oui = Oui::from_bytes(&bytes);
        assert_eq!(oui, Oui::ASUSTek);
    }

    #[test]
    fn test_oui_siemens() {
        let bytes = [0xE0, 0xDC, 0xA0, 0x12, 0x34, 0x56];
        let oui = Oui::from_bytes(&bytes);
        assert_eq!(oui, Oui::Siemens);
    }

    #[test]
    fn test_oui_sagemcom() {
        let bytes = [0xB0, 0x5B, 0x99, 0x12, 0x34, 0x56];
        let oui = Oui::from_bytes(&bytes);
        assert_eq!(oui, Oui::Sagemcom);
    }

    #[test]
    fn test_oui_intel() {
        let bytes = [0x64, 0x6E, 0xE0, 0x12, 0x34, 0x56];
        let oui = Oui::from_bytes(&bytes);
        assert_eq!(oui, Oui::Intel);
    }

    #[test]
    fn test_oui_unknown() {
        let bytes = [0x00, 0x11, 0x22, 0x33, 0x44, 0x55];
        let oui = Oui::from_bytes(&bytes);
        assert_eq!(oui, Oui::Unknown);
    }
}