Struct Integrity

pub struct Integrity {
    pub hashes: Vec<Hash>,
}

Representation of a full Subresource Integrity string.

Integrity can be used for parsing and also includes convenience methods for shorthand versions of IntegrityOpts and IntegrityChecker.

Example

let source = "sha256-uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=";

let parsed: Integrity = source.parse().unwrap();
assert_eq!(parsed.to_string(), source);

Fields

hashes: Vec<Hash>

Implementations

impl Integrity

pub fn pick_algorithm(&self) -> Algorithm

Pick the most secure available Algorithm in this Integrity.

Example

use ssri::{Integrity, Algorithm};

let sri: Integrity = "sha1-deadbeef sha256-badc0ffee".parse().unwrap();
let algorithm = sri.pick_algorithm();
assert_eq!(algorithm, Algorithm::Sha256);

pub fn from<B>(data: B) -> Integrity

where B: AsRef<[u8]>,

Create a new Integrity based on data. Use IntegrityOpts for more options.

Example

use ssri::Integrity;
let sri = Integrity::from(b"hello");
assert_eq!(sri.to_string(), "sha256-LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=".to_owned());

pub fn from_hex<B>(hex: B, algorithm: Algorithm) -> Result<Integrity, Error>

where B: AsRef<[u8]>,

Converts a hex string obtained from to_hex() to an Integrity with a Hash containing algorithm and decoded hex string.

Example

 use ssri::{Integrity, Algorithm};

 let expected = Integrity::from(b"hello");
 let hex = String::from("2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824");
 assert_eq!(Integrity::from_hex(hex, Algorithm::Sha256).unwrap(), expected);

pub fn concat(&self, other: Integrity) -> Integrity

Join together two Integrity instances. Hashes will be grouped and sorted by algorithm but otherwise kept in the same order.

Example

use ssri::Integrity;
let sri1: Integrity = "sha256-deadbeef".parse().unwrap();
let sri2: Integrity = "sha256-badc0ffee".parse().unwrap();
let sri3 = sri1.concat(sri2);
assert_eq!(sri3.to_string(), "sha256-deadbeef sha256-badc0ffee".to_owned());

pub fn check<B>(&self, data: B) -> Result<Algorithm, Error>

where B: AsRef<[u8]>,

Check some data against this Integrity. For more options, use Checker.

Example

use ssri::{Algorithm, Integrity};

let sri = Integrity::from(b"hello");
let algorithm = sri.check(b"hello").unwrap();
assert_eq!(algorithm, Algorithm::Sha256);

pub fn to_hex(&self) -> (Algorithm, String)

Converts the first Hash in this Integrity into its hex string format.

Example

use ssri::{Algorithm, Integrity};

let sri = Integrity::from(b"hello");
let (algo, hex) = sri.to_hex();
assert_eq!(algo, Algorithm::Sha256);
assert_eq!(hex, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824".to_owned());

pub fn matches(&self, other: &Integrity) -> Option<Algorithm>

Compares self against a given SRI to see if there’s a match. The deciding algorithm is determined by other.

Example

use ssri::{Algorithm, Integrity};

let sri1 = Integrity::from(b"hello");
let sri2 = Integrity::from(b"hello").concat(Integrity::from(b"world"));
let m = sri1.matches(&sri2);
assert_eq!(m, Some(Algorithm::Sha256));

Trait Implementations

impl Clone for Integrity

fn clone(&self) -> Integrity

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Integrity

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Integrity

fn deserialize<D>( deserializer: D, ) -> Result<Integrity, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Integrity

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

Formats the value using the given formatter.

impl FromStr for Integrity

fn from_str(s: &str) -> Result<Integrity, <Integrity as FromStr>::Err>

Parses a string into an Integrity instance.

Example

use ssri::Integrity;
let sri: Integrity = "sha256-deadbeef".parse().unwrap();
assert_eq!(sri.to_string(), String::from("sha256-deadbeef"));

type Err = Error

The associated error which can be returned from parsing.

impl Hash for Integrity

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Integrity

fn eq(&self, other: &Integrity) -> 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 Serialize for Integrity

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Integrity

impl StructuralPartialEq for Integrity