Decoding/Verifying with JWK Set or Verifier Selector about josekit-rs HOT 8 CLOSED

let (_verified_claims, _verified_header) =
       jwt::decode_with_verifier_in_jwk_set(token, &jwk_set, |jwk| match jwk.algorithm() {
            Some("RS256") => Ok(Some(&RS256.verifier_from_jwk(jwk)?)),
            Some("P-521") => Ok(Some(&ES512.verifier_from_jwk(jwk)?)),
            _ => Ok(None),
        })?;

use josekit::jwk::alg::ed::{EdCurve, EdKeyPair};
use josekit::jwk::{Jwk, KeyPair};
use josekit::jws::alg::eddsa::{EddsaJwsSigner, EdssaJwsVerifier};
use josekit::jws::{EdDSA, JwsHeader};
use josekit::jwt::{self, JwtPayload};

// generate the keypair and its jwk representations
let keypair: EdKeyPair = EdDSA.generate_key_pair(EdCurve::Ed25519).unwrap();
let jwk_keypair: Jwk = keypair.to_jwk_key_pair();
let jwk_public: Jwk = jwk_keypair.to_public_key().unwrap();

// create a token signer using the private key
let token_signer: EddsaJwsSigner = EdDSA.signer_from_jwk(&jwk_keypair).unwrap();

// generate header and claims to sign
let (header, claims): (JwsHeader, JwtPayload) = create_token();

// sign with the private key
let token: String = jwt::encode_with_signer(&claims, &header, &token_signer).unwrap();

// create a verifier
let token_verifier: EddsaJwsVerifier = EdDSA.verifier_from_jwk(&jwk_public).unwrap();

// verify the claims using a selector that chooses a key based on the header's key id
let (_verified_claims, _verified_header) =
    jwt::decode_with_verifier_selector(token, |header| {
        if let Some(header_key_id) = header.key_id() {
            // if the header's key id matches our key's key id, use that as the verifier
            if header_key_id == jwk_pub.key_id().unwrap() {
                return Ok(Some(&token_verifier));
            }
        }

        Ok(None)
    })
    .unwrap_or_else(|e| {
        eprintln!("Failed to decode/verify token: {}", e);
        exit(1)
    });

pub fn get_jwk_verifier(jwk: &Jwk) -> Option<Box<dyn JwsVerifier>> {
    None.or_else(
        || [ES256, ES384, ES512].iter().find_map(|it|it.verifier_from_jwk(jwk).map(Box::<dyn JwsVerifier>::new).ok())
    ).or_else(
        || [Eddsa].iter().find_map(|it|it.verifier_from_jwk(jwk).map(Box::<dyn JwsVerifier>::new).ok())
    )
}

keyset.keys().into_iter().filter_map(get_jwk_verifier).find_map(|v|josekit::jwt::decode_with_verifier(&create.public_keys_jwt, &v).ok())

let jws_verifiers = JwkSet::from_bytes(bytes)?
            .keys()
            .into_iter()
            .filter_map(|jwk| {
                let kid = jwk.key_id()?.to_string();
                if jwk.key_use() != Some("sig") {
                    return None;
                }
                match jwk.key_type() {
                    "RSA" => Some(RS256.verifier_from_jwk(jwk).map(|v| (kid, v.box_clone()))),
                    "EC" => Some(ES512.verifier_from_jwk(jwk).map(|v| (kid, v.box_clone()))),
                    "OKP" => Some(EdDSA.verifier_from_jwk(jwk).map(|v| (kid, v.box_clone()))),
                    _ => None,
                }
            })
            .collect::<Result<BTreeMap<String, Box<dyn JwsVerifier>>, _>>()?;

        let (payload, _header) = decode_with_verifier_selector(&token, |header| {
            Ok(header
                .key_id()
                .and_then(|kid| jws_verifiers.get(kid))
                .map(|el| el.as_ref()))
        })?;