Struct wasmparser::Validator

pub struct Validator { /* private fields */ }

Available on crate feature validate only.

Validator for a WebAssembly binary module or component.

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 or component.

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 new_with_features(features: WasmFeatures) -> Validator

Creates a new Validator which has the specified set of wasm features activated for validation.

This function is the same as Validator::new except it also allows you to customize the active wasm features in use for validation. This can allow enabling experimental proposals or also turning off on-by-default wasm proposals.

pub fn features(&self) -> &WasmFeatures

Returns the wasm features used for this validator.

pub fn reset(&mut self)

Reset this validator’s state such that it is ready to validate a new Wasm module or component.

This does not clear or reset the internal state keeping track of validated (and deduplicated and canonicalized) types, allowing you to use the same type identifiers (such as CoreTypeId) for the same types that are defined multiple times across different modules and components.

fn foo() -> anyhow::Result<()> {
use wasmparser::Validator;

let mut validator = Validator::default();

// Two wasm modules, both of which define the same type, but at
// different indices in their respective types index spaces.
let wasm1 = wat::parse_str("
    (module
        (type $same_type (func (param i32) (result f64)))
    )
")?;
let wasm2 = wat::parse_str("
    (module
        (type $different_type (func))
        (type $same_type (func (param i32) (result f64)))
    )
")?;

// Validate the first Wasm module and get the ID of its type.
let types = validator.validate_all(&wasm1)?;
let id1 = types.core_type_at(0);

// Reset the validator so we can parse the second wasm module inside
// this validator's same context.
validator.reset();

// Validate the second Wasm module and get the ID of its second type,
// which is the same type as the first Wasm module's only type.
let types = validator.validate_all(&wasm2)?;
let id2 = types.core_type_at(1);

// Because both modules were processed in the same `Validator`, they
// share the same types context and therefore the same type defined
// multiple times across different modules will be deduplicated and
// assigned the same identifier!
assert_eq!(id1, id2);
assert_eq!(types[id1.unwrap_sub()], types[id2.unwrap_sub()]);

pub fn id(&self) -> ValidatorId

Get this validator’s unique identifier.

Allows you to assert that you are always working with the same Validator instance, when you can’t otherwise statically ensure that property by e.g. storing a reference to the validator inside your structure.

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

Validates an entire in-memory module or component with this validator.

This function will internally create a Parser to parse the bytes provided. The entire module or component specified by bytes will be parsed and validated.

Upon success, the type information for the top-level module or component will be returned.

pub fn types(&self, level: usize) -> Option<TypesRef<'_>>

Gets the types known by the validator so far within the module/component level modules/components up from the module/component currently being parsed.

For instance, calling validator.types(0) will get the types of the module/component currently being parsed, and validator.types(1) will get the types of the component containing that module/component.

Returns None if there is no module/component that many levels up.

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: u16, encoding: Encoding, range: &Range<usize>, ) -> 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.

This method should only be called when parsing a module.

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

Validates Payload::FunctionSection.

This method should only be called when parsing a module.

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

Validates Payload::TableSection.

This method should only be called when parsing a module.

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

Validates Payload::MemorySection.

This method should only be called when parsing a module.

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

Validates Payload::TagSection.

This method should only be called when parsing a module.

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

Validates Payload::GlobalSection.

This method should only be called when parsing a module.

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

Validates Payload::ExportSection.

This method should only be called when parsing a module.

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

Validates Payload::StartSection.

This method should only be called when parsing a module.

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

Validates Payload::ElementSection.

This method should only be called when parsing a module.

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

Validates Payload::DataCountSection.

This method should only be called when parsing a module.

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

Validates Payload::CodeSectionStart.

This method should only be called when parsing a module.

pub fn code_section_entry( &mut self, body: &FunctionBody<'_>, ) -> Result<FuncToValidate<ValidatorResources>>

Validates Payload::CodeSectionEntry.

This function will prepare a FuncToValidate which can be used to create a FuncValidator to validate the function. The function body provided will not be parsed or validated by this function.

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

This method should only be called when parsing a module.

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

Validates Payload::DataSection.

This method should only be called when parsing a module.

pub fn module_section(&mut self, range: &Range<usize>) -> Result<()>

Validates Payload::ModuleSection.

This method should only be called when parsing a component.

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

Validates Payload::InstanceSection.

This method should only be called when parsing a component.

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

Validates Payload::CoreTypeSection.

This method should only be called when parsing a component.

pub fn component_section(&mut self, range: &Range<usize>) -> Result<()>

Validates Payload::ComponentSection.

This method should only be called when parsing a component.

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

Validates Payload::ComponentInstanceSection.

This method should only be called when parsing a component.

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

Validates Payload::ComponentAliasSection.

This method should only be called when parsing a component.

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

Validates Payload::ComponentTypeSection.

This method should only be called when parsing a component.

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

Validates Payload::ComponentCanonicalSection.

This method should only be called when parsing a component.

pub fn component_start_section( &mut self, f: &ComponentStartFunction, range: &Range<usize>, ) -> Result<()>

Validates Payload::ComponentStartSection.

This method should only be called when parsing a component.

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

Validates Payload::ComponentImportSection.

This method should only be called when parsing a component.

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

Validates Payload::ComponentExportSection.

This method should only be called when parsing a component.

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

Validates Payload::UnknownSection.

Currently always returns an error.

pub fn end(&mut self, offset: usize) -> Result<Types>

Validates Payload::End.

Returns the types known to the validator for the module or component.

Trait Implementations

impl Default for Validator

fn default() -> Validator

Returns the “default value” for a type.