Struct jsonprooftoken::jwk::key::Jwk

pub struct Jwk {
    pub kid: Option<String>,
    pub pk_use: Option<PKUse>,
    pub key_ops: Option<Vec<KeyOps>>,
    pub alg: Option<Algorithm>,
    pub x5u: Option<String>,
    pub x5c: Option<Vec<String>>,
    pub x5t: Option<String>,
    pub key_params: JwkAlgorithmParameters,
}

JWK parameters defined at https://datatracker.ietf.org/doc/html/rfc7517#section-4

Fields

kid: Option<String>

ID of the key

pk_use: Option<PKUse>

The intended use of the public key

key_ops: Option<Vec<KeyOps>>

The “key_ops” (key operations) parameter identifies the operation(s) for which the key is intended to be used The “use” and “key_ops” JWK members SHOULD NOT be used together; however, if both are used, the information they convey MUST be consistent. Applications should specify which of these members they use, if either is to be used by the application.

alg: Option<Algorithm>

The algorithm intended to be used

x5u: Option<String>

X.509 Public key cerfificate URL.

x5c: Option<Vec<String>>

X.509 public key certificate chain.

x5t: Option<String>

X.509 Certificate thumbprint.

key_params: JwkAlgorithmParameters

Implementations

impl Jwk

pub fn generate(key_type: KeyPairSubtype) -> Result<Self, CustomError>

Examples found in repository

examples/jpt.rs (line 86)

fn main() {

    // let jpt_claims = JptClaims {
    //     sub: Some("user123".to_string()),
    //     exp: Some(1633756800),
    //     nbf: Some(1633670400),
    //     iat: Some(1633666800),
    //     jti: Some("123456".to_string()),
    //     custom: Some(serde_json::json!({
    //         "degree": {
    //             "type": "BachelorDegree",
    //             "name": "Bachelor of Science and Arts",
    //             "ciao": [
    //                 {"u1": "value1"}, 
    //                 {"u2": "value2"}
    //                 ]
    //             },
    //         "name": "John Doe"
    //     })),
    // };
    
   

    let custom_claims = serde_json::json!({
        "family_name": "Doe",
        "given_name": "Jay",
        "email": "jaydoe@example.org",
        "age": 42
    });



    let mut jpt_claims = JptClaims::new();
    // jpt_claims.add_claim("family_name", "Doe");
    // jpt_claims.add_claim("given_name", "Jay");
    // jpt_claims.add_claim("email", "jaydoe@example.org");
    // jpt_claims.add_claim("age", 42);
    jpt_claims.add_claim("", custom_claims, true);

    
    println!("{:?}", jpt_claims);
    let (claims, payloads) = jpt_claims.get_claims_and_payloads();

    println!("Claims: {:?}", claims);
    println!("Payloads: {:?}", payloads);


    let issued_header = IssuerProtectedHeader{
        typ: Some("JPT".to_owned()),
        alg: ProofAlgorithm::BLS12381_SHA256,
        iss: Some("https://issuer.example".to_owned()),
        cid: None,
        claims: Some(claims),
    };

    println!("Issued Header: {:?}", issued_header);

    let issued_jwp = JwpIssued::new(issued_header, payloads);
    println!("ISSUED JWP: \n{:?}", issued_jwp);


    let bbs_jwk = Jwk::generate(KeyPairSubtype::BLS12381SHA256).unwrap();
    println!("BBS Jwk: {:?}", bbs_jwk);
    
    let compact_issued_jwp = issued_jwp.encode(SerializationType::COMPACT, &bbs_jwk).unwrap();
    println!("Compact JWP: {}", compact_issued_jwp);

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

    println!("DECODED ISSUED JWP \n{:?}", decoded_issued_jwp);


    let presentation_header = PresentationProtectedHeader{
        alg: ProofAlgorithm::BLS12381_SHA256_PROOF,
        aud: Some("https://recipient.example.com".to_owned()),
        nonce: Some("wrmBRkKtXjQ".to_owned())
    };

    
    // This is an alternative
    // let presentation_jwp = decoded_issued_jwp.present(SerializationType::COMPACT, &bbs_jwk.to_public().unwrap(), presentation_header);
    
    
    let mut presentation_jwp = JwpPresented::new(decoded_issued_jwp.get_issuer_protected_header().clone(),presentation_header, decoded_issued_jwp.get_payloads().clone());
    presentation_jwp.set_disclosed(1, false).unwrap();
    presentation_jwp.set_disclosed(3, false).unwrap();

    let compact_presented_jwp = presentation_jwp.encode(SerializationType::COMPACT, &bbs_jwk.to_public().unwrap(), decoded_issued_jwp.get_proof().unwrap()).unwrap();

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

    let decoded_presentation_jwp = JwpPresented::decode(compact_presented_jwp, SerializationType::COMPACT, &bbs_jwk.to_public().unwrap()).unwrap();
    println!("DECODED PRESENTED JWP \n{:?}", decoded_presentation_jwp);



    

    // let original = JptClaims::reconstruct_json_value(claims);
    // println!("{:?}", original);
    

    // let claims_map = jpt_claims.to_map();
    // println!("{:?}", claims_map);


    // let deserialized = JptClaims::from_map(claims_map);

    // println!("{:?}", jpt_claims);
    // println!("{:?}", deserialized);
}

pub fn set_kid(&mut self, kid: &str)

pub fn set_pk_use(&mut self, pk_use: PKUse)

pub fn set_key_ops(&mut self, key_ops: Vec<KeyOps>)

pub fn set_alg(&mut self, alg: Algorithm)

pub fn set_x5u(&mut self, x5u: &str)

pub fn set_x5c(&mut self, x5c: Vec<&str>)

pub fn set_x5t(&mut self, x5t: &str)

pub fn is_public(&self) -> bool

Returns true if all private key components of the key are unset, false otherwise.

pub fn is_private(&self) -> bool

Returns true if all private key components of the key are set, false otherwise.

pub fn from_key_params(key_params: JwkAlgorithmParameters) -> Self

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

Examples found in repository

examples/jpt.rs (line 92)

fn main() {

    // let jpt_claims = JptClaims {
    //     sub: Some("user123".to_string()),
    //     exp: Some(1633756800),
    //     nbf: Some(1633670400),
    //     iat: Some(1633666800),
    //     jti: Some("123456".to_string()),
    //     custom: Some(serde_json::json!({
    //         "degree": {
    //             "type": "BachelorDegree",
    //             "name": "Bachelor of Science and Arts",
    //             "ciao": [
    //                 {"u1": "value1"}, 
    //                 {"u2": "value2"}
    //                 ]
    //             },
    //         "name": "John Doe"
    //     })),
    // };
    
   

    let custom_claims = serde_json::json!({
        "family_name": "Doe",
        "given_name": "Jay",
        "email": "jaydoe@example.org",
        "age": 42
    });



    let mut jpt_claims = JptClaims::new();
    // jpt_claims.add_claim("family_name", "Doe");
    // jpt_claims.add_claim("given_name", "Jay");
    // jpt_claims.add_claim("email", "jaydoe@example.org");
    // jpt_claims.add_claim("age", 42);
    jpt_claims.add_claim("", custom_claims, true);

    
    println!("{:?}", jpt_claims);
    let (claims, payloads) = jpt_claims.get_claims_and_payloads();

    println!("Claims: {:?}", claims);
    println!("Payloads: {:?}", payloads);


    let issued_header = IssuerProtectedHeader{
        typ: Some("JPT".to_owned()),
        alg: ProofAlgorithm::BLS12381_SHA256,
        iss: Some("https://issuer.example".to_owned()),
        cid: None,
        claims: Some(claims),
    };

    println!("Issued Header: {:?}", issued_header);

    let issued_jwp = JwpIssued::new(issued_header, payloads);
    println!("ISSUED JWP: \n{:?}", issued_jwp);


    let bbs_jwk = Jwk::generate(KeyPairSubtype::BLS12381SHA256).unwrap();
    println!("BBS Jwk: {:?}", bbs_jwk);
    
    let compact_issued_jwp = issued_jwp.encode(SerializationType::COMPACT, &bbs_jwk).unwrap();
    println!("Compact JWP: {}", compact_issued_jwp);

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

    println!("DECODED ISSUED JWP \n{:?}", decoded_issued_jwp);


    let presentation_header = PresentationProtectedHeader{
        alg: ProofAlgorithm::BLS12381_SHA256_PROOF,
        aud: Some("https://recipient.example.com".to_owned()),
        nonce: Some("wrmBRkKtXjQ".to_owned())
    };

    
    // This is an alternative
    // let presentation_jwp = decoded_issued_jwp.present(SerializationType::COMPACT, &bbs_jwk.to_public().unwrap(), presentation_header);
    
    
    let mut presentation_jwp = JwpPresented::new(decoded_issued_jwp.get_issuer_protected_header().clone(),presentation_header, decoded_issued_jwp.get_payloads().clone());
    presentation_jwp.set_disclosed(1, false).unwrap();
    presentation_jwp.set_disclosed(3, false).unwrap();

    let compact_presented_jwp = presentation_jwp.encode(SerializationType::COMPACT, &bbs_jwk.to_public().unwrap(), decoded_issued_jwp.get_proof().unwrap()).unwrap();

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

    let decoded_presentation_jwp = JwpPresented::decode(compact_presented_jwp, SerializationType::COMPACT, &bbs_jwk.to_public().unwrap()).unwrap();
    println!("DECODED PRESENTED JWP \n{:?}", decoded_presentation_jwp);



    

    // let original = JptClaims::reconstruct_json_value(claims);
    // println!("{:?}", original);
    

    // let claims_map = jpt_claims.to_map();
    // println!("{:?}", claims_map);


    // let deserialized = JptClaims::from_map(claims_map);

    // println!("{:?}", jpt_claims);
    // println!("{:?}", deserialized);
}

Trait Implementations

impl Clone for Jwk

fn clone(&self) -> Jwk

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Jwk

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Jwk

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

Deserialize this value from the given Serde deserializer.

impl PartialEq for Jwk

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

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 Jwk

impl StructuralEq for Jwk

impl StructuralPartialEq for Jwk