Struct PrimaryHeader 

pub struct PrimaryHeader {
    pub version: u8,
    pub size: u64,
    pub timestamp: u64,
    pub encryption_type: HeaderEncryptionType,
    pub name: [u8; 64],
    pub arch: ImageArch,
    pub directory_nonce: [u8; 12],
    pub directory_offset: u64,
    pub directory_size: u32,
    pub public: u8,
    pub reserved: [u8; 64],
}

Contains metadata which is always plaintext. Anything potentially useful to an attacker should instead reside in the protected header unless the user may want to read it without decrypting the image first.

Fields

version: u8

The format version

size: u64

The total size of all blocks combined in bytes

timestamp: u64

Image creation time

encryption_type: HeaderEncryptionType

The encryption type for metadata

name: [u8; 64]

A copy of the name field from the config

arch: ImageArch

System architecture

directory_nonce: [u8; 12]

Directory nonce

directory_offset: u64

The byte offset of the directory

directory_size: u32

The size of the directory in bytes

public: u8

Whether the image is public

reserved: [u8; 64]

Extra space for the future

Implementations

impl PrimaryHeader

pub fn name(&self) -> String

pub fn is_public(&self) -> bool

Trait Implementations

impl BinRead for PrimaryHeader

type Args<'__binrw_generated_args_lifetime> = ()

The type used for the args parameter of read_args() and read_options().

fn read_options<R: Read + Seek>( __binrw_generated_var_reader: &mut R, __binrw_generated_var_endian: Endian, __binrw_generated_var_arguments: Self::Args<'_>, ) -> BinResult<Self>

Read Self from the reader using the given Endian and arguments.

fn read<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self: ReadEndian, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments.

fn read_be<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments and assuming big-endian byte order.

fn read_le<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments and assuming little-endian byte order.

fn read_ne<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read T from the reader assuming native-endian byte order.

fn read_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek, Self: ReadEndian,

Read Self from the reader using the given arguments.

fn read_be_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read Self from the reader, assuming big-endian byte order, using the given arguments.

fn read_le_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read Self from the reader, assuming little-endian byte order, using the given arguments.

fn read_ne_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read T from the reader, assuming native-endian byte order, using the given arguments.

impl BinWrite for PrimaryHeader

type Args<'__binrw_generated_args_lifetime> = ()

The type used for the args parameter of write_args() and write_options().

fn write_options<W: Write + Seek>( &self, __binrw_generated_var_writer: &mut W, __binrw_generated_var_endian: Endian, __binrw_generated_var_arguments: Self::Args<'_>, ) -> BinResult<()>

Write Self to the writer using the given Endian and arguments.

fn write<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek, Self: WriteEndian, Self::Args<'a>: for<'a> Required,

Write Self to the writer using default arguments.

fn write_be<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming big-endian byte order.

fn write_le<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming little-endian byte order.

fn write_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek, Self: WriteEndian,

Write Self to the writer using the given arguments.

fn write_be_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek,

Write Self to the writer, assuming big-endian byte order, using the given arguments.

fn write_le_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek,

Write Self to the writer, assuming little-endian byte order, using the given arguments.

impl Debug for PrimaryHeader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for PrimaryHeader

fn eq(&self, other: &PrimaryHeader) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ReadEndian for PrimaryHeader

const ENDIAN: EndianKind

The endianness of the type.

impl ReadMagic for PrimaryHeader

const MAGIC: Self::MagicType

The magic number.

type MagicType = [u8; 4]

The type of the magic number.

impl WriteEndian for PrimaryHeader

const ENDIAN: EndianKind

The endianness of the type.

impl WriteMagic for PrimaryHeader

const MAGIC: Self::MagicType

The magic number.

type MagicType = [u8; 4]

The type of the magic number.

impl Eq for PrimaryHeader

impl StructuralPartialEq for PrimaryHeader