hex

To use hex in a no_std environment, disable the default features in your Cargo.toml. Note that if you need support for allocation types like String in a no_std environment, you should ensure the alloc feature is enabled (it is enabled by default unless you explicitly disable all features).

[dependencies]
hex = { version = "0.4", default-features = false }

Add hex to your Cargo.toml dependencies. By default, it includes std support. If you are working in a no_std environment, you must disable default features.

[dependencies]
hex = "0.4"

Use hex::decode to convert a hexadecimal string back into bytes. This typically returns a Result<Vec<u8>, DecodeError>, so you will need to handle potential errors (e.g., using .unwrap() or proper error handling) before converting the bytes back into a usable format like a String.

let decoded_string = String::from_utf8(hex::decode("48656c6c6f20776f726c6421").unwrap()).unwrap();

println!("{}", decoded_string); // Prints "Hello world!"

Use hex::encode to convert a string or byte slice into its hexadecimal representation.

let hex_string = hex::encode("Hello world!");

println!("{}", hex_string); // Prints "48656c6c6f20776f726c6421"

The hex crate provides several feature flags to control its capabilities:

• std: Enabled by default. Adds support for Rust's libstd types.
• alloc: Enabled by default. Adds support for alloc types (e.g., String) in no_std environments.
• serde: Disabled by default. Adds support for the serde serialization/deserialization library.

The hex crate follows an MSRV policy tied to the current stable Debian release to ensure compatibility with stable Linux distributions. As of the current version, the MSRV is Rust 1.85 (matching Debian Trixie stable).

You can verify the current requirement by checking the rust-version field in Cargo.toml or by checking the current stable Rust version provided by Debian at https://packages.debian.org/stable/rustc.

[package]
rust-version = "1.85"

Use encode_upper() to convert a byte slice or any type implementing AsRef<[u8]> into an uppercase hex String. This requires the alloc feature.

assert_eq!(hex::encode_upper("Hello world!"), "48656C6C6F20776F726C6421");
assert_eq!(hex::encode_upper(vec![1, 2, 3, 15, 16]), "0102030F10");

When the alloc feature is enabled, use serialize_upper to convert a type implementing ToHex into an uppercase hex string during Serde serialization.

#[cfg(feature = "alloc")]
pub fn serialize_upper<S, T>(data: T, serializer: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
    T: ToHex,

Encodes bytes into a mutable slice of bytes using lowercase characters.

Constraints:

• The output buffer must be exactly input.len() * 2 bytes long. If the buffer is larger or smaller, it returns Err(FromHexError::InvalidStringLength).

let mut bytes = [0u8; 4 * 2];
hex::encode_to_slice(b"kiwi", &mut bytes).unwrap();
assert_eq!(&bytes, b"6b697769");

Decodes a hex string into a provided mutable byte slice.

Constraints:

• The input hex string length must be exactly twice the length of the output slice.
• The input hex string must have an even length.

Returns Err(FromHexError::InvalidStringLength) if the lengths do not match correctly.

let mut bytes = [0u8; 4];
hex::decode_to_slice("6b697769", &mut bytes).unwrap();
assert_eq!(&bytes, b"kiwi");

Use encode() to convert a byte slice or any type implementing AsRef<[u8]> into a lowercase hex String. This requires the alloc feature.

Note: The resulting string's length is always even, containing exactly twice as many characters as the input data has bytes.

assert_eq!(hex::encode("Hello world!"), "48656c6c6f20776f726c6421");
assert_eq!(hex::encode(vec![1, 2, 3, 15, 16]), "0102030f10");