Struct apple_codesign::MachOBinary

pub struct MachOBinary<'a> {
    pub index: Option<usize>,
    pub macho: MachO<'a>,
    pub data: &'a [u8],
}

A Mach-O binary.

Fields

index: Option<usize>

Index within a fat binary this Mach-O resides at.

If None, this is not inside a fat binary.

macho: MachO<'a>

The parsed Mach-O binary.

data: &'a [u8]

The raw data backing the Mach-O binary.

Implementations

impl<'a> MachOBinary<'a>

pub fn parse(data: &'a [u8]) -> Result<Self, AppleCodesignError>

Parse a non-universal Mach-O binary from raw data.

impl<'a> MachOBinary<'a>

pub fn find_signature_data(
    &self
) -> Result<Option<MachOSignatureData<'a>>, AppleCodesignError>

Attempt to extract a reference to raw signature data in a Mach-O binary.

An LC_CODE_SIGNATURE load command in the Mach-O file header points to signature data in the __LINKEDIT segment.

This function is used as part of parsing signature data. You probably want to use a function that parses referenced data.

pub fn code_signature(
    &self
) -> Result<Option<EmbeddedSignature<'_>>, AppleCodesignError>

Obtain the code signature in the entity.

Returns Ok(None) if no signature exists, Ok(Some) if it does, or Err if there is a parse error.

pub fn executable_segment_boundary(
    &self
) -> Result<(u64, u64), AppleCodesignError>

Determine the start and end offset of the executable segment of a binary.

pub fn is_executable(&self) -> bool

Whether this is an executable Mach-O file.

pub fn code_signature_linkedit_start_offset(&self) -> Option<u32>

The start offset of the code signature data within the __LINKEDIT segment.

pub fn code_signature_linkedit_end_offset(&self) -> Option<u32>

The end offset of the code signature data within the __LINKEDIT segment.

pub fn segments_by_file_offset(&self) -> Vec<&Segment<'a>>

Obtain Mach-O segments by file offset order.

The header-defined order may vary by the file layout order. This ensures the ordering is by file layout.

pub fn code_limit_binary_offset(&self) -> Result<u64, AppleCodesignError>

The byte offset within the binary at which point “code” stops.

If a signature is present, this is the offset of the start of the signature. Else it represents the end of the binary.

pub fn linkedit_data_before_signature(&self) -> Option<&[u8]>

Obtain __LINKEDIT segment data before the signature data.

If there is no signature, returns all the data for the __LINKEDIT segment.

pub fn digested_code_data(&self) -> Result<&[u8], AppleCodesignError>

Obtain Mach-O binary data to be digested in code digests.

Returns the raw data whose digests will be captured by the Code Directory code digests.

pub fn code_digests_size(
    &self,
    digest: DigestType,
    page_size: usize
) -> Result<usize, AppleCodesignError>

Obtain the size in bytes of all code digests given a digest type and page size.

pub fn code_digests(
    &self,
    digest: DigestType,
    page_size: usize
) -> Result<Vec<Vec<u8>>, AppleCodesignError>

Compute digests over code in this binary.

pub fn code_signature_load_command(&self) -> Option<LinkeditDataCommand>

Resolve the load command for the code signature.

pub fn embedded_info_plist(&self) -> Result<Option<Vec<u8>>, AppleCodesignError>

Attempt to locate embedded Info.plist data.

pub fn check_signing_capability(&self) -> Result<(), AppleCodesignError>

Determines whether this crate is capable of signing a given Mach-O binary.

Code in this crate is limited in the amount of Mach-O binary manipulation it can perform (supporting rewriting all valid Mach-O binaries effectively requires low-level awareness of all Mach-O constructs in order to perform offset manipulation). This function can be used to test signing compatibility.

We currently only support signing Mach-O files already containing an embedded signature. Often linked binaries automatically contain an embedded signature containing just the code directory (without a cryptographically signed signature), so this limitation hopefully isn’t impactful.

pub fn estimate_embedded_signature_size(
    &self,
    settings: &SigningSettings<'_>
) -> Result<usize, AppleCodesignError>

Estimate the size in bytes of an embedded code signature.

pub fn find_targeting(&self) -> Result<Option<MachoTarget>, AppleCodesignError>

Attempt to resolve the mach-o targeting settings.