Struct wasmparser::Validator

pub struct Validator { /* fields omitted */ }

Validator for a WebAssembly binary module.

This structure encapsulates state necessary to validate a WebAssembly binary. This implements validation as defined by the core specification. A Validator is designed, like Parser, to accept incremental input over time. Additionally a Validator is also designed for parallel validation of functions as they are received.

It's expected that you'll be using a Parser in tandem with a Validator. As each Payload is received from a Parser you'll pass it into a Validator to test the validity of the payload. Note that all payloads received from a Parser are expected to be passed to a Validator. For example if you receive Payload::TypeSection you'll call Validator::type_section to validate this.

The design of Validator is intended that you'll interleave, in your own application's processing, calls to validation. Each variant, after it's received, will be validated and then your application would proceed as usual. At all times, however, you'll have access to the Validator and the validation context up to that point. This enables applications to check the types of functions and learn how many globals there are, for example.

Implementations

impl Validator

pub fn new() -> Validator

Creates a new Validator ready to validate a WebAssembly module.

The new validator will receive payloads parsed from Parser, and expects the first payload received to be the version header from the parser.

pub fn wasm_features(&mut self, features: WasmFeatures) -> &mut Validator

Configures the enabled WebAssembly features for this Validator.

pub fn validate_all(&mut self, bytes: &[u8]) -> Result<()>

Validates an entire in-memory module with this validator.

This function will internally create a Parser to parse the bytes provided. The entire wasm module specified by bytes will be parsed and validated. Parse and validation errors will be returned through Err(_), and otherwise a successful validation means Ok(()) is returned.

pub fn payload<'a>(&mut self, payload: &Payload<'a>) -> Result<ValidPayload<'a>>

Convenience function to validate a single Payload.

This function is intended to be used as a convenience. It will internally perform any validation necessary to validate the Payload provided. The convenience part is that you're likely already going to be matching on Payload in your application, at which point it's more appropriate to call the individual methods on Validator per-variant in Payload, such as Validator::type_section.

This function returns a ValidPayload variant on success, indicating one of a few possible actions that need to be taken after a payload is validated. For example function contents are not validated here, they're returned through ValidPayload for validation by the caller.

pub fn version(&mut self, num: u32, range: &Range) -> Result<()>

Validates Payload::Version

pub fn type_section(&mut self, section: &TypeSectionReader<'_>) -> Result<()>

Validates Payload::TypeSection

pub fn import_section(
    &mut self,
    section: &ImportSectionReader<'_>
) -> Result<()>

Validates Payload::ImportSection

pub fn module_section_start(&mut self, count: u32, range: &Range) -> Result<()>

Validates Payload::ModuleSectionStart

pub fn module_section_entry(&mut self)

Validates Payload::ModuleSectionEntry.

Note that this does not actually perform any validation itself. The ModuleSectionEntry payload is associated with a sub-parser for the sub-module, and it's expected that the events from the Parser are fed into this validator.

pub fn alias_section(&mut self, section: &AliasSectionReader<'_>) -> Result<()>

Validates Payload::AliasSection

pub fn instance_section(
    &mut self,
    section: &InstanceSectionReader<'_>
) -> Result<()>

Validates Payload::InstanceSection

pub fn function_section(
    &mut self,
    section: &FunctionSectionReader<'_>
) -> Result<()>

Validates Payload::FunctionSection

pub fn table_section(&mut self, section: &TableSectionReader<'_>) -> Result<()>

Validates Payload::TableSection

pub fn memory_section(
    &mut self,
    section: &MemorySectionReader<'_>
) -> Result<()>

pub fn event_section(&mut self, section: &EventSectionReader<'_>) -> Result<()>

pub fn global_section(
    &mut self,
    section: &GlobalSectionReader<'_>
) -> Result<()>

Validates Payload::GlobalSection

pub fn export_section(
    &mut self,
    section: &ExportSectionReader<'_>
) -> Result<()>

Validates Payload::ExportSection

pub fn start_section(&mut self, func: u32, range: &Range) -> Result<()>

Validates Payload::StartSection

pub fn element_section(
    &mut self,
    section: &ElementSectionReader<'_>
) -> Result<()>

Validates Payload::ElementSection

pub fn data_count_section(&mut self, count: u32, range: &Range) -> Result<()>

Validates Payload::DataCountSection

pub fn code_section_start(&mut self, count: u32, range: &Range) -> Result<()>

Validates Payload::CodeSectionStart.

pub fn code_section_entry(
    &mut self
) -> Result<FuncValidator<ValidatorResources>>

Validates Payload::CodeSectionEntry.

This function will prepare a FuncValidator which can be used to validate the function. The function body provided will be parsed only enough to create the function validation context. After this the OperatorsReader returned can be used to read the opcodes of the function as well as feed information into the validator.

Note that the returned FuncValidator is "connected" to this Validator in that it uses the internal context of this validator for validating the function. The FuncValidator can be sent to another thread, for example, to offload actual processing of functions elsewhere.

pub fn data_section(&mut self, section: &DataSectionReader<'_>) -> Result<()>

Validates Payload::DataSection.

pub fn unknown_section(&mut self, id: u8, range: &Range) -> Result<()>

Validates Payload::UnknownSection.

Currently always returns an error.

pub fn end(&mut self) -> Result<()>

Validates Payload::End.

Trait Implementations

impl Default for Validator

fn default() -> Validator

Returns the "default value" for a type.