https://github.com/michael-yuji/mini-ipmi
#![no-std] Rust library for serialize/deserialize IPMI / ASF / RMCP data
https://github.com/michael-yuji/mini-ipmi
ipmi rust
Last synced: 4 months ago
JSON representation
#![no-std] Rust library for serialize/deserialize IPMI / ASF / RMCP data
- Host: GitHub
- URL: https://github.com/michael-yuji/mini-ipmi
- Owner: michael-yuji
- Created: 2022-04-22T17:46:25.000Z (over 3 years ago)
- Default Branch: main
- Last Pushed: 2022-04-22T19:40:04.000Z (over 3 years ago)
- Last Synced: 2025-06-14T21:03:19.179Z (4 months ago)
- Topics: ipmi, rust
- Language: Rust
- Homepage:
- Size: 17.6 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# mini-ipmi
`#![no-std]`:
This is a Rust crate that serialize / deserialize IPMI over LAN data.
This crate does not depend on `std` nor need `alloc`.
This crate support serialize/deserialize generic IPMI request/response to/from
byte slices. *Battery is not yet included*, user of the crate will have to
implement their own logic for anything useful.
For IPMI over LAN, IPMI 1.5 and RMCP is supported.
IPMI 2.0 / RMCP+ is not supported yet.
:::info
Instead of creating many enum and type to provide more contextual and typed
value. This crate is sticking with raw values (like `u8`). The reason behind
it is mostly to support unconventional usages like pan-testing / security
research. In the future this may change, or being offered as a separate feature
:::
## Usage
Assume we have an arary of bytes containing an IPMI over RMCP message.
The following example to to decode the RMCP message and validate the message
is not malformed. Allowing non-strict decoding can be useful for some usages
like security research.
Decoding to typed IPMI request/response is also supported
### Deserialize
```rust
let·bytes·=·[
/* RMCP header */
0x06,·0x00,·0xff,·0x07,
/* IPMI1.5 header*/
0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x09,
/* IPMI GetChannelAuthCapabilities Request */
0x20,0x18,0xc8,0x81,0x04,0x38,0x0e,0x04,0x31
];
let validate_msg: bool = true;
let rmcp_message = RmcpMessage::from_bytes(&bytes, validate_msg)?;
if let RmcpContent::Ipmi15(ipmi_pkt) = rmcp_message.data {
/* IPMI 1.5 session data */
assert_eq!(ipmi_pkt.session_id, 0u32);
assert_eq!(ipmi_pkt.seqnum, 0u32);
/* down field `data` for IPMI message header */
assert_eq!(ipmi_pkt.data.netfn, 0x06u8);
/**
* Some Ipmi command that's included in this crate can be decoded directly
* to a typed value.
*/
if let Some(GetChannelAuthCap::Request(req)) =
GetChannelAuthCap::from_message(&ipmi_pkt.data) {
assert_eq!(req.channel_number, 0xe);
}
/* to decode any request message, and deal with the raw bytes */
if let IpmiData::Request(rq_bytes) = ipmi_pkt.data.data {
todo!();
}
/* to decode any response message, and deal with the raw bytes */
if let IpmiData::Response(rs_code, rs_bytes) = ipmi_pkt.data.data {
panic!("The byte array in this example contais req data, not res");
}
}
```
### Serialize
:::warning
:warning: Unlike `copy_from_slice` in rust, `write_to_slice` in this crate
can write to slice with size greater or equals to the content it's going
to write. use `foo.size()` to get the size it will be written.
:::
```rust
/* continue from previous code block */
let mut out = [0u8; 23];
rmcp_message.write_to_slice(&mut out, validate_msg);
assert_eq!(out, bytes);
```
## IPMI over LAN overview
This section breifly describe how IPMI over LAN work and their mapping to `struct`/`enum` in this crate.
IPMI is basically a req/res protocol. The req/res and their header
(`ipmi::IpmiMessage` in this crate) are encapsulated in multiple layers when
using LAN as a medium for transportation.
In the case of IPMI 1.5, data are first wrapped within a IPMI 1.5 session wrapper,
which contains information about the session id, seq number, and optionally cryptographic signature. (`ipmi::Ipmi15Packet`).
Finally the packet is encapulated in a RMCP packet (`rmcp::RMCPMessage`). The
purpose of RMCP is to "multiplex" different protocol. For example, service
discovery is done by responding ASF pong message (`asf::AsfMessage`) via ASF
over RMCP.