Struct jsonprooftoken::jpt::claims::JptClaims

pub struct JptClaims {
    pub iss: Option<String>,
    pub sub: Option<String>,
    pub exp: Option<i64>,
    pub nbf: Option<i64>,
    pub iat: Option<i64>,
    pub jti: Option<String>,
    pub custom: IndexMap<String, Value>,
}

These claims are taken from the JWT RFC (https://tools.ietf.org/html/rfc7519) making the hypothesis that in the future will be used also for the JPTs *

Fields

iss: Option<String>

Apparently the “aud” that in JWT was a claim, now should be an presentation protected header parameter (https://datatracker.ietf.org/doc/html/draft-ietf-jose-json-web-proof#name-presentation-protected-head) * Who issued the JWP

sub: Option<String>

Subject of the JPT.

exp: Option<i64>

Expiration time

nbf: Option<i64>

Time before which the JPT MUST NOT be accepted

iat: Option<i64>

Issue time

jti: Option<String>

Unique ID for the JPT.

custom: IndexMap<String, Value>

Other custom claims (age, name, surname, Verifiable Credential, …)

Implementations

impl JptClaims

pub fn new() -> Self

Examples found in repository

examples/jpt.rs (line 40)

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::BLS12381_SHA256);

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

    let issued_jwp = JwpIssuedBuilder::new()
    .issuer_protected_header(issued_header)
    .jpt_claims(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 = JwpIssuedVerifier::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(ProofAlgorithm::BLS12381_SHA256_PROOF);
    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)
    .presentation_protected_header(presentation_header)
    .set_disclosed_payload(1, false).unwrap()
    .set_disclosed_payload(3, false).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 = JwpPresentedVerifier::decode(&compact_presented_jwp, SerializationType::COMPACT).unwrap()
    .verify(&bbs_jwk.to_public().unwrap())
    .unwrap();

}

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

Examples found in repository

examples/jpt.rs (line 41)

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::BLS12381_SHA256);

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

    let issued_jwp = JwpIssuedBuilder::new()
    .issuer_protected_header(issued_header)
    .jpt_claims(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 = JwpIssuedVerifier::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(ProofAlgorithm::BLS12381_SHA256_PROOF);
    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)
    .presentation_protected_header(presentation_header)
    .set_disclosed_payload(1, false).unwrap()
    .set_disclosed_payload(3, false).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 = JwpPresentedVerifier::decode(&compact_presented_jwp, SerializationType::COMPACT).unwrap()
    .verify(&bbs_jwk.to_public().unwrap())
    .unwrap();

}

pub fn set_sub(&mut self, value: String)

pub fn set_exp(&mut self, value: i64)

pub fn set_nbf(&mut self, value: i64)

pub fn set_iat(&mut self, value: i64)

pub fn set_jti(&mut self, value: String)

pub fn set_claim<T: Serialize>( &mut self, claim: Option<&str>, value: T, flattened: bool )

Examples found in repository

examples/jpt.rs (line 42)

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::BLS12381_SHA256);

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

    let issued_jwp = JwpIssuedBuilder::new()
    .issuer_protected_header(issued_header)
    .jpt_claims(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 = JwpIssuedVerifier::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(ProofAlgorithm::BLS12381_SHA256_PROOF);
    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)
    .presentation_protected_header(presentation_header)
    .set_disclosed_payload(1, false).unwrap()
    .set_disclosed_payload(3, false).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 = JwpPresentedVerifier::decode(&compact_presented_jwp, SerializationType::COMPACT).unwrap()
    .verify(&bbs_jwk.to_public().unwrap())
    .unwrap();

}

pub fn get_claim(&self, claim: &str) -> Option<&Value>

pub fn get_claims_and_payloads(&self) -> (Claims, Payloads)

Extracts claims and payloads into separate vectors.

pub fn from_claims_and_payloads(claims: &Claims, payloads: &Payloads) -> Self

Reconstruct JptClaims from Claims and Payloads

Trait Implementations

impl Clone for JptClaims

fn clone(&self) -> JptClaims

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for JptClaims

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

Formats the value using the given formatter.

impl Default for JptClaims

fn default() -> JptClaims

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for JptClaims

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for JptClaims

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for JptClaims

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 JptClaims

impl StructuralEq for JptClaims

impl StructuralPartialEq for JptClaims