Struct ssri::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>

Methods

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: AsRef<[u8]>>(data: B) -> Integrity

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 concat(&self, other: Integrity) -> Self

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: AsRef<[u8]>>(&self, data: B) -> Result<Algorithm, Error>

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: &Self) -> 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 Eq for Integrity

impl PartialEq<Integrity> for Integrity

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Display for Integrity

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

Formats the value using the given formatter.

impl Debug for Integrity

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

Formats the value using the given formatter.

impl FromStr for Integrity

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Integrity, Self::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"));

impl Serialize for Integrity

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

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

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.