Struct PresentationProtectedHeader

pub struct PresentationProtectedHeader { /* private fields */ }

Implementations

impl PresentationProtectedHeader

pub fn new(alg: PresentationProofAlgorithm) -> Self

Constructor for PresentationProtectedHeader, sets the PresentationProofAlgorithm

Examples found in repository

examples/jpt.rs (lines 67-72)

fn main() {
    let custom_claims = serde_json::json!({
        "degree": {
            "type": "BachelorDegree",
            "name": "Bachelor of Science and Arts",
            "ciao": [
                {"u1": "value1"},
                {"u2": "value2"}
                ]
            },
        "name": "John Doe"
    });

    let mut jpt_claims = JptClaims::new();
    jpt_claims.set_iss("https://issuer.example".to_owned());
    jpt_claims.set_claim(Some("vc"), custom_claims, true);

    let issued_header = IssuerProtectedHeader::new(ProofAlgorithm::BBS);

    let bbs_jwk = Jwk::generate(KeyPairSubtype::BLS12381G2Sha256).unwrap();
    println!(
        "\nBBS Jwk:\n {:#}",
        serde_json::to_string_pretty(&bbs_jwk).unwrap()
    );

    let issued_jwp = JwpIssuedBuilder::new(issued_header, jpt_claims)
        .build(&bbs_jwk)
        .unwrap();

    let compact_issued_jwp = issued_jwp.encode(SerializationType::COMPACT).unwrap();
    println!("\nCompact Issued JWP: {}", compact_issued_jwp);

    let decoded_issued_jwp =
        JwpIssuedDecoder::decode(&compact_issued_jwp, SerializationType::COMPACT)
            .unwrap()
            .verify(&bbs_jwk.to_public().unwrap())
            .unwrap();

    assert_eq!(issued_jwp, decoded_issued_jwp);

    let mut presentation_header = PresentationProtectedHeader::new(
        decoded_issued_jwp
            .get_issuer_protected_header()
            .alg()
            .into(),
    );
    presentation_header.set_aud(Some("https://recipient.example.com".to_owned()));
    presentation_header.set_nonce(Some("wrmBRkKtXjQ".to_owned()));

    let presented_jwp = JwpPresentedBuilder::new(&decoded_issued_jwp)
        .set_presentation_protected_header(presentation_header)
        .set_undisclosed("vc.degree.name")
        .unwrap()
        .set_undisclosed("vc.degree.ciao[0].u1")
        .unwrap()
        .set_undisclosed("vc.name")
        .unwrap()
        .build(&bbs_jwk.to_public().unwrap())
        .unwrap();

    let compact_presented_jwp = presented_jwp.encode(SerializationType::COMPACT).unwrap();

    println!("\nCompact Presented JWP: {}", compact_presented_jwp);

    let _decoded_presented_jwp =
        JwpPresentedDecoder::decode(&compact_presented_jwp, SerializationType::COMPACT)
            .unwrap()
            .verify(&bbs_jwk.to_public().unwrap())
            .unwrap();
}

pub fn alg(&self) -> PresentationProofAlgorithm

Getter for alg

pub fn kid(&self) -> Option<&String>

Getter for kid

pub fn set_kid(&mut self, value: Option<String>)

Setter for kid

pub fn aud(&self) -> Option<&String>

Getter for aud

pub fn set_aud(&mut self, value: Option<String>)

Setter for aud

Examples found in repository

examples/jpt.rs (line 73)

fn main() {
    let custom_claims = serde_json::json!({
        "degree": {
            "type": "BachelorDegree",
            "name": "Bachelor of Science and Arts",
            "ciao": [
                {"u1": "value1"},
                {"u2": "value2"}
                ]
            },
        "name": "John Doe"
    });

    let mut jpt_claims = JptClaims::new();
    jpt_claims.set_iss("https://issuer.example".to_owned());
    jpt_claims.set_claim(Some("vc"), custom_claims, true);

    let issued_header = IssuerProtectedHeader::new(ProofAlgorithm::BBS);

    let bbs_jwk = Jwk::generate(KeyPairSubtype::BLS12381G2Sha256).unwrap();
    println!(
        "\nBBS Jwk:\n {:#}",
        serde_json::to_string_pretty(&bbs_jwk).unwrap()
    );

    let issued_jwp = JwpIssuedBuilder::new(issued_header, jpt_claims)
        .build(&bbs_jwk)
        .unwrap();

    let compact_issued_jwp = issued_jwp.encode(SerializationType::COMPACT).unwrap();
    println!("\nCompact Issued JWP: {}", compact_issued_jwp);

    let decoded_issued_jwp =
        JwpIssuedDecoder::decode(&compact_issued_jwp, SerializationType::COMPACT)
            .unwrap()
            .verify(&bbs_jwk.to_public().unwrap())
            .unwrap();

    assert_eq!(issued_jwp, decoded_issued_jwp);

    let mut presentation_header = PresentationProtectedHeader::new(
        decoded_issued_jwp
            .get_issuer_protected_header()
            .alg()
            .into(),
    );
    presentation_header.set_aud(Some("https://recipient.example.com".to_owned()));
    presentation_header.set_nonce(Some("wrmBRkKtXjQ".to_owned()));

    let presented_jwp = JwpPresentedBuilder::new(&decoded_issued_jwp)
        .set_presentation_protected_header(presentation_header)
        .set_undisclosed("vc.degree.name")
        .unwrap()
        .set_undisclosed("vc.degree.ciao[0].u1")
        .unwrap()
        .set_undisclosed("vc.name")
        .unwrap()
        .build(&bbs_jwk.to_public().unwrap())
        .unwrap();

    let compact_presented_jwp = presented_jwp.encode(SerializationType::COMPACT).unwrap();

    println!("\nCompact Presented JWP: {}", compact_presented_jwp);

    let _decoded_presented_jwp =
        JwpPresentedDecoder::decode(&compact_presented_jwp, SerializationType::COMPACT)
            .unwrap()
            .verify(&bbs_jwk.to_public().unwrap())
            .unwrap();
}

pub fn nonce(&self) -> Option<&String>

Getter for nonce

pub fn set_nonce(&mut self, value: Option<String>)

Setter for nonce

Examples found in repository

examples/jpt.rs (line 74)

fn main() {
    let custom_claims = serde_json::json!({
        "degree": {
            "type": "BachelorDegree",
            "name": "Bachelor of Science and Arts",
            "ciao": [
                {"u1": "value1"},
                {"u2": "value2"}
                ]
            },
        "name": "John Doe"
    });

    let mut jpt_claims = JptClaims::new();
    jpt_claims.set_iss("https://issuer.example".to_owned());
    jpt_claims.set_claim(Some("vc"), custom_claims, true);

    let issued_header = IssuerProtectedHeader::new(ProofAlgorithm::BBS);

    let bbs_jwk = Jwk::generate(KeyPairSubtype::BLS12381G2Sha256).unwrap();
    println!(
        "\nBBS Jwk:\n {:#}",
        serde_json::to_string_pretty(&bbs_jwk).unwrap()
    );

    let issued_jwp = JwpIssuedBuilder::new(issued_header, jpt_claims)
        .build(&bbs_jwk)
        .unwrap();

    let compact_issued_jwp = issued_jwp.encode(SerializationType::COMPACT).unwrap();
    println!("\nCompact Issued JWP: {}", compact_issued_jwp);

    let decoded_issued_jwp =
        JwpIssuedDecoder::decode(&compact_issued_jwp, SerializationType::COMPACT)
            .unwrap()
            .verify(&bbs_jwk.to_public().unwrap())
            .unwrap();

    assert_eq!(issued_jwp, decoded_issued_jwp);

    let mut presentation_header = PresentationProtectedHeader::new(
        decoded_issued_jwp
            .get_issuer_protected_header()
            .alg()
            .into(),
    );
    presentation_header.set_aud(Some("https://recipient.example.com".to_owned()));
    presentation_header.set_nonce(Some("wrmBRkKtXjQ".to_owned()));

    let presented_jwp = JwpPresentedBuilder::new(&decoded_issued_jwp)
        .set_presentation_protected_header(presentation_header)
        .set_undisclosed("vc.degree.name")
        .unwrap()
        .set_undisclosed("vc.degree.ciao[0].u1")
        .unwrap()
        .set_undisclosed("vc.name")
        .unwrap()
        .build(&bbs_jwk.to_public().unwrap())
        .unwrap();

    let compact_presented_jwp = presented_jwp.encode(SerializationType::COMPACT).unwrap();

    println!("\nCompact Presented JWP: {}", compact_presented_jwp);

    let _decoded_presented_jwp =
        JwpPresentedDecoder::decode(&compact_presented_jwp, SerializationType::COMPACT)
            .unwrap()
            .verify(&bbs_jwk.to_public().unwrap())
            .unwrap();
}

pub fn typ(&self) -> Option<&String>

Getter for typ

pub fn set_typ(&mut self, value: Option<String>)

Setter for typ

pub fn crit(&self) -> Option<&Vec<String>>

Getter for crit

pub fn set_crit(&mut self, value: Option<Vec<String>>)

Setter for claims

pub fn iss(&self) -> Option<&String>

Getter for iss

pub fn set_iss(&mut self, value: Option<String>)

Setter for iss

pub fn presentation_key(&self) -> Option<Jwk>

Getter for presentation_key

pub fn set_presentation_key(&mut self, value: Option<Jwk>)

Setter for presentation_key

Trait Implementations

impl Clone for PresentationProtectedHeader

fn clone(&self) -> PresentationProtectedHeader

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PresentationProtectedHeader

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PresentationProtectedHeader

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PresentationProtectedHeader

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for PresentationProtectedHeader

impl StructuralPartialEq for PresentationProtectedHeader