fastmcp-protocol 0.14.0

MCP protocol types and JSON-RPC implementation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
//! Real-signature enterprise verification regression fixtures.
//!
//! Every compact value below was signed with the public example RSA key from
//! RFC 7515 Appendix A.2. Fixture preparation first reproduced that appendix's
//! known-answer signature. Only its public JWK and signed assertions are kept;
//! these tests require no signer, private key, network, clock or random source.

use std::sync::OnceLock;

use serde_json::json;

use super::*;

const ISSUER: &str = "https://idp.example";
const GENERATION: u64 = 7;
const ISSUED: u64 = 2_000_000_000;

fn at(seconds: u64) -> SystemTime {
    UNIX_EPOCH + Duration::from_secs(seconds)
}

fn now() -> SystemTime {
    at(ISSUED + 120)
}

fn oidc_keys() -> OidcVerificationKeys {
    OidcVerificationKeys::from_trusted_jwks(ISSUER, GENERATION, PUBLIC_JWKS.as_bytes())
        .expect("admitted OIDC fixture key")
}

fn id_jag_keys() -> IdJagVerificationKeys {
    IdJagVerificationKeys::from_trusted_jwks(ISSUER, GENERATION, PUBLIC_JWKS.as_bytes())
        .expect("separately admitted ID-JAG fixture key")
}

fn oidc_expected() -> OidcIdTokenExpectations<'static> {
    OidcIdTokenExpectations {
        client_id: "native-idp",
        nonce: "oidc-flow-nonce",
        access_token: Some("temporary-access"),
        tenant: TenantExpectation::SingleTenant,
        max_authentication_age: None,
        time: JwtTimePolicy::oidc_default(),
    }
}

fn id_jag_expected() -> IdJagExpectations<'static> {
    IdJagExpectations {
        audience: "https://as.example",
        client_id: "native-resource",
        resource: "https://mcp.example/mcp",
        require_resource: true,
        idp_tenant: TenantExpectation::SingleTenant,
        resource_tenant: ResourceTenantExpectation::SingleTenant,
        time: JwtTimePolicy::id_jag_default(),
    }
}

fn signed(name: &str) -> &'static str {
    static FIXTURES: OnceLock<Value> = OnceLock::new();
    FIXTURES.get_or_init(|| serde_json::from_str(SIGNED_FIXTURES).expect("fixture JSON"))[name]
        .as_str()
        .expect("named signed fixture")
}

fn oidc_failure(name: &str, error: EnterpriseVerificationError) {
    assert_eq!(
        verify_oidc_id_token(signed(name), &oidc_keys(), &oidc_expected(), now()).unwrap_err(),
        error,
        "{name}",
    );
}

fn id_jag_failure(name: &str, error: EnterpriseVerificationError) {
    assert_eq!(
        verify_id_jag(signed(name), &id_jag_keys(), &id_jag_expected(), now()).unwrap_err(),
        error,
        "{name}",
    );
}

#[test]
fn signed_oidc_and_id_jag_return_only_their_bound_identity_facts() {
    let oidc_keys = oidc_keys();
    let jag_keys = id_jag_keys();
    let oidc =
        verify_oidc_id_token(signed("oidc_base"), &oidc_keys, &oidc_expected(), now()).unwrap();
    let jag = verify_id_jag(signed("id_jag_base"), &jag_keys, &id_jag_expected(), now()).unwrap();

    assert_eq!(oidc.issuer(), ISSUER);
    assert_eq!(oidc.client_id(), "native-idp");
    assert_eq!(oidc.subject().as_str(), "client-facing");
    assert!(oidc.tenant().is_none());
    assert_eq!(oidc.issued_at(), at(ISSUED));
    assert_eq!(oidc.expires_at(), at(ISSUED + 240));
    assert_eq!(oidc.authentication_time(), Some(at(ISSUED)));
    assert_eq!(oidc.key_id(), "enterprise-rfc7515");
    assert_eq!(oidc.generation(), GENERATION);
    assert_eq!(
        oidc.compact_digest(),
        sha256_bounded(signed("oidc_base").as_bytes(), MAX_COMPACT_JWS_BYTES).unwrap(),
    );
    assert_eq!(jag.issuer(), ISSUER);
    assert_eq!(jag.audience(), "https://as.example");
    assert_eq!(jag.client_id(), "native-resource");
    assert_eq!(jag.subject().as_str(), "resource-facing");
    assert!(jag.idp_tenant().is_none());
    assert!(jag.resource_tenant().is_none());
    assert!(jag.audience_subject().is_none());
    assert_eq!(jag.resource(), Some("https://mcp.example/mcp"));
    assert_eq!(jag.scope(), Some("read"));
    assert_eq!(jag.jti(), "id-jag-flow-1");
    assert_eq!(jag.issued_at(), at(ISSUED));
    assert_eq!(jag.expires_at(), at(ISSUED + 240));
    assert_eq!(jag.key_id(), "enterprise-rfc7515");
    assert_eq!(jag.generation(), GENERATION);
    assert_eq!(
        jag.compact_digest(),
        sha256_bounded(signed("id_jag_base").as_bytes(), MAX_COMPACT_JWS_BYTES).unwrap(),
    );
    assert_ne!(oidc.compact_digest(), jag.compact_digest());
    assert_eq!(oidc_keys.document_digest(), jag_keys.document_digest());

    let diagnostic = format!("{oidc:?} {jag:?} {:?} {:?}", oidc.subject(), jag.subject());
    for secret in [
        signed("oidc_base"),
        signed("id_jag_base"),
        "client-facing",
        "resource-facing",
        "temporary-access",
        "oidc-flow-nonce",
        "id-jag-flow-1",
    ] {
        assert!(!diagnostic.contains(secret));
    }
}

#[test]
fn signed_singleton_audiences_and_media_type_case_variants_are_accepted() {
    let oidc = verify_oidc_id_token(
        signed("oidc_singleton"),
        &oidc_keys(),
        &oidc_expected(),
        now(),
    )
    .unwrap();
    let jag = verify_id_jag(
        signed("id_jag_singleton"),
        &id_jag_keys(),
        &id_jag_expected(),
        now(),
    )
    .unwrap();
    assert_eq!(oidc.client_id(), "native-idp");
    assert_eq!(jag.resource(), Some("https://mcp.example/mcp"));
    oidc_failure(
        "oidc_multi_audience",
        EnterpriseVerificationError::BindingMismatch,
    );
    oidc_failure("oidc_null_azp", EnterpriseVerificationError::InvalidClaims);
    id_jag_failure(
        "id_jag_multi_audience",
        EnterpriseVerificationError::BindingMismatch,
    );
    id_jag_failure(
        "id_jag_multi_resource",
        EnterpriseVerificationError::BindingMismatch,
    );
}

#[test]
fn valid_signatures_cannot_change_the_trusted_flow_or_resource_bindings() {
    let keys = oidc_keys();
    let mut expected = oidc_expected();
    expected.client_id = "other-client";
    assert_eq!(
        verify_oidc_id_token(signed("oidc_base"), &keys, &expected, now()).unwrap_err(),
        EnterpriseVerificationError::BindingMismatch,
    );
    let mut expected = oidc_expected();
    expected.nonce = "other-flow-nonce";
    assert_eq!(
        verify_oidc_id_token(signed("oidc_base"), &keys, &expected, now()).unwrap_err(),
        EnterpriseVerificationError::InvalidNonce,
    );
    oidc_failure(
        "oidc_foreign_issuer",
        EnterpriseVerificationError::BindingMismatch,
    );

    let keys = id_jag_keys();
    for changed in ["audience", "client", "resource"] {
        let mut expected = id_jag_expected();
        match changed {
            "audience" => expected.audience = "https://other.example",
            "client" => expected.client_id = "other-client",
            "resource" => expected.resource = "https://mcp.example/other",
            _ => unreachable!(),
        }
        assert_eq!(
            verify_id_jag(signed("id_jag_base"), &keys, &expected, now()).unwrap_err(),
            EnterpriseVerificationError::BindingMismatch,
            "{changed}",
        );
    }
}

#[test]
fn signed_at_hash_requires_the_exact_access_token_and_canonical_128_bits() {
    let keys = oidc_keys();
    for token in [None, Some("different-access-token")] {
        let mut expected = oidc_expected();
        expected.access_token = token;
        assert_eq!(
            verify_oidc_id_token(signed("oidc_base"), &keys, &expected, now()).unwrap_err(),
            EnterpriseVerificationError::InvalidAccessTokenHash,
        );
    }
    oidc_failure(
        "oidc_hash_padding",
        EnterpriseVerificationError::InvalidAccessTokenHash,
    );
    oidc_failure(
        "oidc_hash_trailing_bits",
        EnterpriseVerificationError::InvalidAccessTokenHash,
    );

    let mut expected = oidc_expected();
    expected.access_token = None;
    assert!(verify_oidc_id_token(signed("oidc_without_hash"), &keys, &expected, now()).is_ok());
    expected.access_token = Some("credential with spaces");
    assert_eq!(
        verify_oidc_id_token(signed("oidc_without_hash"), &keys, &expected, now()).unwrap_err(),
        EnterpriseVerificationError::InvalidConfiguration,
    );
}

#[test]
fn signed_tenants_use_separate_exact_namespaces_without_normalization() {
    let mut expected = oidc_expected();
    expected.tenant = TenantExpectation::Exact("e\u{301}");
    let verified =
        verify_oidc_id_token(signed("oidc_tenant"), &oidc_keys(), &expected, now()).unwrap();
    assert_eq!(verified.tenant().unwrap().as_str(), "e\u{301}");
    assert!(!format!("{:?}", verified.tenant()).contains("e\u{301}"));
    expected.tenant = TenantExpectation::Exact("\u{e9}");
    assert_eq!(
        verify_oidc_id_token(signed("oidc_tenant"), &oidc_keys(), &expected, now()).unwrap_err(),
        EnterpriseVerificationError::BindingMismatch,
    );
    oidc_failure("oidc_tenant", EnterpriseVerificationError::BindingMismatch);
    oidc_failure(
        "oidc_null_tenant",
        EnterpriseVerificationError::BindingMismatch,
    );

    let mut expected = id_jag_expected();
    expected.idp_tenant = TenantExpectation::Exact("idp-tenant");
    expected.resource_tenant = ResourceTenantExpectation::Exact("resource-tenant");
    let verified =
        verify_id_jag(signed("id_jag_tenants"), &id_jag_keys(), &expected, now()).unwrap();
    assert_eq!(verified.idp_tenant().unwrap().as_str(), "idp-tenant");
    assert_eq!(
        verified.resource_tenant().unwrap().as_str(),
        "resource-tenant"
    );
    assert_eq!(
        verified.audience_subject().unwrap().as_str(),
        "opaque/account"
    );
    assert_eq!(
        verify_id_jag(
            signed("id_jag_tenant_missing_subject"),
            &id_jag_keys(),
            &expected,
            now(),
        )
        .unwrap_err(),
        EnterpriseVerificationError::InvalidClaims,
    );
    expected.resource_tenant = ResourceTenantExpectation::Exact("idp-tenant");
    assert_eq!(
        verify_id_jag(signed("id_jag_tenants"), &id_jag_keys(), &expected, now()).unwrap_err(),
        EnterpriseVerificationError::BindingMismatch,
    );
    id_jag_failure(
        "id_jag_tenants",
        EnterpriseVerificationError::BindingMismatch,
    );
}

#[test]
fn signed_optional_resource_and_scope_remain_explicit_caller_policy() {
    id_jag_failure(
        "id_jag_missing_resource",
        EnterpriseVerificationError::BindingMismatch,
    );
    let mut expected = id_jag_expected();
    expected.require_resource = false;
    let without_resource = verify_id_jag(
        signed("id_jag_missing_resource"),
        &id_jag_keys(),
        &expected,
        now(),
    )
    .unwrap();
    assert!(without_resource.resource().is_none());
    assert_eq!(without_resource.scope(), Some("read"));
    let without_scope = verify_id_jag(
        signed("id_jag_missing_scope"),
        &id_jag_keys(),
        &id_jag_expected(),
        now(),
    )
    .unwrap();
    assert!(without_scope.scope().is_none());
    id_jag_failure(
        "id_jag_duplicate_scope",
        EnterpriseVerificationError::InvalidClaims,
    );
    id_jag_failure(
        "id_jag_empty_jti",
        EnterpriseVerificationError::InvalidClaims,
    );
}

#[test]
fn signed_claims_and_headers_cannot_cross_the_closed_enterprise_profiles() {
    for name in [
        "oidc_forbidden_cnf",
        "oidc_forbidden_disclosure",
        "oidc_subject_nonascii",
    ] {
        oidc_failure(name, EnterpriseVerificationError::InvalidClaims);
    }
    for name in [
        "oidc_duplicate_claim",
        "oidc_nested_type",
        "oidc_remote_key",
        "oidc_unknown_key",
    ] {
        oidc_failure(name, EnterpriseVerificationError::InvalidToken);
    }
    for name in ["id_jag_forbidden_cnf", "id_jag_forbidden_actor"] {
        id_jag_failure(name, EnterpriseVerificationError::InvalidClaims);
    }
    for name in ["id_jag_missing_type", "id_jag_oidc_type"] {
        id_jag_failure(name, EnterpriseVerificationError::InvalidToken);
    }
    assert_eq!(
        verify_oidc_id_token(signed("id_jag_base"), &oidc_keys(), &oidc_expected(), now())
            .unwrap_err(),
        EnterpriseVerificationError::InvalidToken,
    );
    assert_eq!(
        verify_id_jag(
            signed("oidc_base"),
            &id_jag_keys(),
            &id_jag_expected(),
            now()
        )
        .unwrap_err(),
        EnterpriseVerificationError::InvalidToken,
    );
    let mut corrupted = signed("oidc_base").to_owned();
    let signature = corrupted.rfind('.').unwrap() + 1;
    let changed = if &corrupted[signature..=signature] == "A" {
        "B"
    } else {
        "A"
    };
    corrupted.replace_range(signature..=signature, changed);
    assert_eq!(
        verify_oidc_id_token(&corrupted, &oidc_keys(), &oidc_expected(), now()).unwrap_err(),
        EnterpriseVerificationError::InvalidToken,
    );
}

#[test]
fn signed_numeric_dates_retain_nanoseconds_and_equivalent_exponents() {
    let fraction = verify_oidc_id_token(
        signed("oidc_fraction_time"),
        &oidc_keys(),
        &oidc_expected(),
        now(),
    )
    .unwrap();
    assert_eq!(fraction.issued_at(), at(ISSUED) + Duration::from_nanos(1));
    assert_eq!(
        fraction.expires_at(),
        at(ISSUED + 240) + Duration::from_nanos(1)
    );
    let exponent = verify_oidc_id_token(
        signed("oidc_exponent_time"),
        &oidc_keys(),
        &oidc_expected(),
        now(),
    )
    .unwrap();
    assert_eq!(exponent.issued_at(), at(ISSUED));
    assert_eq!(exponent.expires_at(), at(ISSUED + 240));
    oidc_failure(
        "oidc_bad_precision",
        EnterpriseVerificationError::InvalidTime,
    );
    oidc_failure(
        "oidc_negative_zero",
        EnterpriseVerificationError::InvalidTime,
    );
}

#[test]
fn signed_times_enforce_exact_expiration_future_and_authentication_boundaries() {
    let keys = oidc_keys();
    let expected = oidc_expected();
    assert!(verify_oidc_id_token(signed("oidc_base"), &keys, &expected, at(ISSUED - 60),).is_ok());
    assert_eq!(
        verify_oidc_id_token(signed("oidc_base"), &keys, &expected, at(ISSUED - 61)).unwrap_err(),
        EnterpriseVerificationError::NotYetValid,
    );
    assert!(
        verify_oidc_id_token(
            signed("oidc_base"),
            &keys,
            &expected,
            at(ISSUED + 300) - Duration::from_nanos(1),
        )
        .is_ok()
    );
    assert_eq!(
        verify_oidc_id_token(signed("oidc_base"), &keys, &expected, at(ISSUED + 300)).unwrap_err(),
        EnterpriseVerificationError::Expired,
    );
    assert!(
        verify_oidc_id_token(signed("oidc_not_before"), &keys, &expected, at(ISSUED + 60),).is_ok()
    );
    assert_eq!(
        verify_oidc_id_token(signed("oidc_not_before"), &keys, &expected, at(ISSUED + 59))
            .unwrap_err(),
        EnterpriseVerificationError::NotYetValid,
    );
    let mut expected = oidc_expected();
    expected.time = JwtTimePolicy::new(Duration::from_secs(239), Duration::from_secs(60)).unwrap();
    assert_eq!(
        verify_oidc_id_token(signed("oidc_base"), &keys, &expected, now()).unwrap_err(),
        EnterpriseVerificationError::InvalidTime,
    );
    let mut expected = oidc_expected();
    expected.max_authentication_age = Some(Duration::from_secs(60));
    assert!(verify_oidc_id_token(signed("oidc_base"), &keys, &expected, now()).is_ok());
    assert_eq!(
        verify_oidc_id_token(
            signed("oidc_base"),
            &keys,
            &expected,
            now() + Duration::from_nanos(1),
        )
        .unwrap_err(),
        EnterpriseVerificationError::Expired,
    );
    assert_eq!(
        verify_oidc_id_token(signed("oidc_without_auth_time"), &keys, &expected, now())
            .unwrap_err(),
        EnterpriseVerificationError::InvalidClaims,
    );
    oidc_failure(
        "oidc_future_auth_time",
        EnterpriseVerificationError::InvalidTime,
    );

    let mut expected = id_jag_expected();
    expected.time = JwtTimePolicy::oidc_default();
    assert_eq!(
        verify_id_jag(signed("id_jag_base"), &id_jag_keys(), &expected, now()).unwrap_err(),
        EnterpriseVerificationError::InvalidConfiguration,
    );
    assert_eq!(
        verify_id_jag(
            signed("id_jag_base"),
            &id_jag_keys(),
            &id_jag_expected(),
            at(ISSUED + 300),
        )
        .unwrap_err(),
        EnterpriseVerificationError::Expired,
    );
}

#[test]
fn numeric_dates_have_closed_precision_range_and_sign() {
    for (lexeme, expected) in [
        ("0", Duration::ZERO),
        ("0e-9999", Duration::ZERO),
        ("1", Duration::from_secs(1)),
        ("1.0000000000", Duration::from_secs(1)),
        ("10e-1", Duration::from_secs(1)),
        ("1e-9", Duration::from_nanos(1)),
        ("10e-10", Duration::from_nanos(1)),
        ("2000000000.000000001", Duration::new(ISSUED, 1)),
        (
            "253402300799.999999999",
            Duration::new(253_402_300_799, 999_999_999),
        ),
    ] {
        let value = serde_json::from_str(lexeme).unwrap();
        assert_eq!(numeric_date(&value), Ok(expected), "{lexeme}");
    }
    for lexeme in [
        "-0",
        "-0.0",
        "-1",
        "1e-10",
        "1.0000000001",
        "253402300800",
        "1e9999",
        "0e10000",
        "100000000000000000000000000000000",
        r#""2000000000""#,
        "null",
    ] {
        let value = serde_json::from_str(lexeme).unwrap();
        assert_eq!(
            numeric_date(&value),
            Err(EnterpriseVerificationError::InvalidTime),
            "{lexeme}",
        );
    }
}

#[test]
fn scope_grammar_limits_are_exact_and_duplicates_do_not_grant_more_scope() {
    fn parse(scope: Value) -> Result<Option<String>, EnterpriseVerificationError> {
        let claims = json!({"scope": scope});
        scope_claim(claims.as_object().unwrap())
    }
    let maximum_count = (0..MAX_ENTERPRISE_SCOPE_COUNT)
        .map(|index| format!("scope-{index}"))
        .collect::<Vec<_>>()
        .join(" ");
    assert_eq!(parse(json!(maximum_count)), Ok(Some(maximum_count.clone())));
    assert!(parse(json!(format!("{maximum_count} another"))).is_err());
    let maximum_token = "x".repeat(MAX_ENTERPRISE_SCOPE_BYTES);
    assert_eq!(parse(json!(maximum_token)), Ok(Some(maximum_token.clone())));
    assert!(parse(json!("x".repeat(MAX_ENTERPRISE_SCOPE_BYTES + 1))).is_err());

    let mut maximum_set = (0..16)
        .map(|index| format!("{index:02}{}", "a".repeat(253)))
        .collect::<Vec<_>>();
    maximum_set[0].push('a');
    let maximum_set = maximum_set.join(" ");
    assert_eq!(maximum_set.len(), MAX_ENTERPRISE_SCOPE_SET_BYTES);
    assert!(parse(json!(maximum_set)).is_ok());
    assert!(parse(json!(format!("{maximum_set}a"))).is_err());
    for scope in [
        "",
        "read read",
        " read",
        "read ",
        "read  write",
        "read\twrite",
        "read\u{a0}write",
        "read\"write",
        "read\\write",
    ] {
        assert_eq!(
            parse(json!(scope)),
            Err(EnterpriseVerificationError::InvalidClaims)
        );
    }
    for scope in [Value::Null, json!(["read"]), json!(3)] {
        assert_eq!(
            parse(scope),
            Err(EnterpriseVerificationError::InvalidClaims)
        );
    }
}

#[test]
fn trusted_imports_reject_repaired_urls_invalid_generations_and_wrong_key_use() {
    for issuer in [
        "http://idp.example",
        "https://idp.example?query",
        "https://idp.example#fragment",
        "https://user@idp.example",
        r"https:\\idp.example",
        "https:///idp.example",
        " https://idp.example",
    ] {
        assert_eq!(
            OidcVerificationKeys::from_trusted_jwks(issuer, GENERATION, PUBLIC_JWKS.as_bytes())
                .err(),
            Some(EnterpriseVerificationError::InvalidConfiguration),
            "{issuer}",
        );
        assert_eq!(
            IdJagVerificationKeys::from_trusted_jwks(issuer, GENERATION, PUBLIC_JWKS.as_bytes())
                .err(),
            Some(EnterpriseVerificationError::InvalidConfiguration),
            "{issuer}",
        );
    }
    assert_eq!(
        OidcVerificationKeys::from_trusted_jwks(ISSUER, 0, PUBLIC_JWKS.as_bytes()).err(),
        Some(EnterpriseVerificationError::InvalidConfiguration),
    );
    let mut wrong_use: Value = serde_json::from_str(PUBLIC_JWKS).unwrap();
    wrong_use["keys"][0]["key_ops"] = json!(["sign"]);
    let bytes = serde_json::to_vec(&wrong_use).unwrap();
    assert_eq!(
        IdJagVerificationKeys::from_trusted_jwks(ISSUER, GENERATION, &bytes).err(),
        Some(EnterpriseVerificationError::InvalidKeys),
    );
    let oidc = oidc_keys();
    let jag = id_jag_keys();
    assert_eq!(oidc.issuer(), ISSUER);
    assert_eq!(jag.issuer(), ISSUER);
    assert_eq!(oidc.generation(), GENERATION);
    assert_eq!(jag.generation(), GENERATION);

    for (lifetime, skew) in [
        (Duration::ZERO, Duration::ZERO),
        (
            MAX_ENTERPRISE_TOKEN_LIFETIME + Duration::from_secs(1),
            Duration::ZERO,
        ),
        (
            Duration::from_secs(1),
            MAX_ENTERPRISE_CLOCK_SKEW + Duration::from_secs(1),
        ),
    ] {
        assert_eq!(
            JwtTimePolicy::new(lifetime, skew),
            Err(EnterpriseVerificationError::InvalidConfiguration),
        );
    }
    assert_eq!(JwtTimePolicy::default(), JwtTimePolicy::oidc_default());
    assert_eq!(
        JwtTimePolicy::id_jag_default().max_lifetime(),
        Duration::from_secs(300)
    );
    assert_eq!(
        JwtTimePolicy::oidc_default().clock_skew(),
        Duration::from_secs(60)
    );
}

#[test]
fn verification_errors_never_echo_compact_or_identity_input() {
    for error in [
        EnterpriseVerificationError::InvalidConfiguration,
        EnterpriseVerificationError::InvalidKeys,
        EnterpriseVerificationError::InvalidToken,
        EnterpriseVerificationError::InvalidClaims,
        EnterpriseVerificationError::BindingMismatch,
        EnterpriseVerificationError::InvalidTime,
        EnterpriseVerificationError::Expired,
        EnterpriseVerificationError::NotYetValid,
        EnterpriseVerificationError::InvalidNonce,
        EnterpriseVerificationError::InvalidAccessTokenHash,
    ] {
        let message = format!("{error} {error:?}");
        for sensitive in [
            ISSUER,
            "client-facing",
            "resource-facing",
            "oidc-flow-nonce",
            "temporary-access",
            signed("oidc_base"),
            signed("id_jag_base"),
        ] {
            assert!(!message.contains(sensitive));
        }
    }
}

const PUBLIC_JWKS: &str = r#"{"keys":[{"kty":"RSA","kid":"enterprise-rfc7515","alg":"RS256","use":"sig","n":"ofgWCuLjybRlzo0tZWJjNiuSfb4p4fAkd_wWJcyQoTbji9k0l8W26mPddxHmfHQp-Vaw-4qPCJrcS2mJPMEzP1Pt0Bm4d4QlL-yRT-SFd2lZS-pCgNMsD1W_YpRPEwOWvG6b32690r2jZ47soMZo9wGzjb_7OMg0LOL-bSf63kpaSHSXndS5z5rexMdbBYUsLA9e-KXBdQOS-UTo7WTBEMa2R2CapHg665xsmtdVMTBQY4uDZlxvb3qCo5ZwKh9kG4LT6_I5IhlJH7aGhyxXFvUK-DWNmoudF8NAco9_h9iaGNj8q2ethFkMLs91kzk2PAcDTW9gb54h4FRWyuXpoQ","e":"AQAB"}]}"#;

const SIGNED_FIXTURES: &str = r#"
{
  "oidc_base": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIn0.aiXjCgHfEAfh_5efvRZ8G5cdfJiKRmUemPNk6xZzEb1twmX_8uRiiQFpE67CXrOfDZrlR5QFHG4Mx8w4bdiZwogSAJbfJ_BrZ9yUeH5J7ZZmjKEtuRFoOKUUg6uiPUEGzkoZFVVDjAjBA_sCSTKO-oNEZczV2iQTIfGA_DaBlpFxZMQ1dLM2jExuTmrlBUqg0rKvVvcrDFUN3B9gHAgi8DlJPWATiiPSmKRiEqw_iQ7qG8a6dNVPVQNlpEG1Bhn-R2UUX6hOaXiKZ8MvyXE8A567Fm0pqyDF1SLKMRp9a5nyprxdpy7sb96FhhBccZ6O78JcLjyOBrMPZbFjgBMtew",
  "id_jag_base": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6Im9hdXRoLWlkLWphZytqd3QifQ.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjoiaHR0cHM6Ly9hcy5leGFtcGxlIiwiY2xpZW50X2lkIjoibmF0aXZlLXJlc291cmNlIiwianRpIjoiaWQtamFnLWZsb3ctMSIsImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJyZXNvdXJjZSI6Imh0dHBzOi8vbWNwLmV4YW1wbGUvbWNwIiwic2NvcGUiOiJyZWFkIn0.RB4rbITee-1mWu0P5urfsvlRWZqjEjr5EsRlHZd6OrZGb0oBE23dqq2wV4gg-vFqybo94yGVM6QZAyXcaLuFPlGHAY8ctSab0hPlz6wt1rdLuxNlSF34T7CztMV841Aint_uKOG3ELZD4XkAW7z6ojjdjvVhddbn5Uk7IS4AkXF8ucDMnhHOOpIYYyy6s8vMDjHMeBczL0pNuVxDrG8CrCXzkhluXeXFJBaKPMq3NBY2Jj0PVg2eNqJjua7aIr9h9z0jC_vOA7PVpWv5k3_dP38Y8-CJi0zo3CxVSSURpFMO4dnlqToKKw_lP95cPHH52ndn43sj2-dGmx-3Lucycg",
  "oidc_singleton": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6IkFQUExJQ0FUSU9OL0pXVCJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6WyJuYXRpdmUtaWRwIl0sImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJhdXRoX3RpbWUiOjIwMDAwMDAwMDAsIm5vbmNlIjoib2lkYy1mbG93LW5vbmNlIiwiYXRfaGFzaCI6InFJQkNfWnRUWVh1MkVsdjk5RDlDLUEiLCJhenAiOiJuYXRpdmUtaWRwIn0.kEHhnlqZiglrUr8eDwVIFhxUhO5DtzuyWISVrIB6bcLmdNSscAE53FBjM1DrDNWKQLvY2hn55Kr6gaMLn0RDjrO1uIJwmbqVDn3RHGugJCAwsdwgRDl4nYElHMxo_E5V6-cEa2nRkU7UG34UUTGSiTD_OLtW-fu5ldRrO_Flaoe29XPPKJWGf7acTKno4UPgQQrZ6PqdURYvBpFMLuj1okZQwUtrcafN2hG1y6ascpCZ18NuRJn6x23rKo9cAPdvMzXYWi5Rqi7mmKqRuCoC2l_2Goic14erg99n94OyOJJuQy1OfPpojxYIfAs6I_kxVDPFFIW0cOikzvl2m0dD-A",
  "oidc_multi_audience": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6WyJuYXRpdmUtaWRwIiwib3RoZXItY2xpZW50Il0sImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJhdXRoX3RpbWUiOjIwMDAwMDAwMDAsIm5vbmNlIjoib2lkYy1mbG93LW5vbmNlIiwiYXRfaGFzaCI6InFJQkNfWnRUWVh1MkVsdjk5RDlDLUEifQ.S9e0bUWTN-btKoOCKqwBv2gWkxM9KLp2EqF3MzxGc3KenarDcRke4qu7SWsnKxXcz8mAe742WOtw-Fe7WVGwEUX_zXmCew7j_CBV8Kru4rryzhdBABjzIkxFTnrxDtu2RupkoiZKddofLtXRJLoozZWVLgecRE17o7-WAmH7gBsvFxMWO3Pjl-HPtx35PfgD7mRdIjzSqBpQNy_3javbiadNvha9DCeuiWcAxK-je8PLv6ss14jN7KARRIpseOYJ-ANR4X0zLrByYP47NPtvCTCCqqc2SXQ3m8RNR2_xsSIyqjXhU6WxbcALORYEOfhlEp4OGWbexk_jGhimHnf7Vw",
  "oidc_null_azp": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIiwiYXpwIjpudWxsfQ.aDh-xGQHqF4iQ-b0_CgOsv0vt9PNAhjrJ-QNrPWRAbM5kTL-RvJQfY-8D3l9LdluS5OLfl54he4bKPJcrDi2zN72mQnoxb4dYZ9Z8NZMz9HWGPcK3WPannwPgAbdzSw8z-iDxHud320YTtdSSJ5LXoKjEjZk_Cofbk_Ysi0wYedBG9bAHgGk7SVjiBdZljoM8iM3v2TRi3-KA74_AmhMcO1zvcpxqmfpA6gpYJMU7dfFygyH29IN4PBg92--ldQDZUtfEnsEI5ZIzXg6uDJRfdVVSnpIbeANzHifjSJytbEEK6zs_a60ajxK59MNCM5QzeR1o9Y6DHH8HRRjIpMG4w",
  "oidc_tenant": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIiwidGVuYW50IjoiZcyBIn0.d4h93jRBgHYbAIAwZgc15WLEJ84H1Pl2jbfnKRsbx1-fR8PzdZaxqvVuX2dnpS5bxMJdlOW_x6HMLmp0gSu8NCLqCJ40d5Dp-GPMiCtp09DVPgNCCVi36P4-wIUhfINsLb4TyVHUE2WHhE9V5umiJ-vQEXUkm0U4nIki8thBsb1wyviUxMWl-9vDgl8ZhTZSSmSwJXD0EX21bnwbc011FsbFNaXhbLq9MLkVsylbSYYMciueOXpyY35OjtfA5YvLDtng4uh93xAr37L93JUZnZPUz3S2G6l5RwvFNFIeeBGE9hAYbkRxaclLrD_VZFTaXVhGxzYBt5yPemef65QyGw",
  "oidc_null_tenant": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIiwidGVuYW50IjpudWxsfQ.mQJU8pKAaEIh-4h-KpbCiOCTdQr2OL9V1e77_ZUfkqhN9Wi_v8rUN_0vfCvfN8MFSitrSyycHHLPtLB0Ida1nbOhvj-sN842kwV7L1EEGUfbATmZFbXCEika1gPPsVAwbdIAf6ZKfuDQ5Qb1NNzibsuIAiXeCDD6io8tSaM7YDPme-W4d7P1ddFd54w7KY_0MdR8BLL-XVCd9NaQpdKdFykx3pZgRb5yyZY3BAuD1ToT0c1BxfLmYBPhSPdgkQmN2_687d0QZQKOOmh0dBwlsQ2tMTepU7WFBF7tSZYAuEJsnGapSvykFaHnlxDtuvpdw7ZTSp4CmwtD8Y2HLBMUBQ",
  "oidc_forbidden_cnf": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIiwiY25mIjp7ImprdCI6InVudXNlZCJ9fQ.XMXFRcLFKHEhH_tlWXRWAiXRjRa2Qy2WcLkkfqxXZaMjfn-EX_tWqKS2-_yc1tdOMbD9GmgK2OrptYl6pQdrMcL_weW9CGNf0xDTQMi-iFgRXAM-zgmAQG8ks04kpOxAbETfEN1_E3AHKeSuHjXFHmzAoslWtuzRA806mY_sAfRQzsf2BTKzt1y7_1KhacX4-qvX_MKBcWUnLcEABTWbz7JeBULTggHJQqm4PLb1X_nbB-ce6IYsvwhx6T5IkHcDt9VBCLpB_5ULi4UnKSuV5kYX4qE0EdW2QDqe1v8GrsqW2sk67R5oyEJu4qGwPwTflSlz9LUZTmKVoSSLISDhrw",
  "oidc_forbidden_disclosure": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIiwiYXVkX3N1YiI6ImFjY291bnQtYWxpYXMifQ.CGky58sN0nYmS-EFm8PJ0TLrc69twWqDO7bDLNpFFyuSL1uboMeCI5BJkpeWRDqNE5XSJA3I1c8p_H9N5mw_DHKfUhTHTYMZGaqH_Tn8kj38QN9BGwzRDfPY-C8-4ukLl3n-_fS4vJXHuzo8PvX6wDbhLOTMMSS_bbWmKDMJisvRkalJZapZynpRAZqwPD3SH--NT6hyoJYqpC52fDxb3odcDY0qnywK4AvnQ3QlrtVAWwVTwDIGAWqkT276gS2umXKGkcdXUizmwso9hi6irdtxbngxoHrEnj8Ln7iacQV5B1PqUVqogLxKncE8qSI2hKpskYyj2f6bK_OSu7ooCw",
  "oidc_hash_padding": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BPSJ9.jgwQgm5FcxD_shiBDAZwGvr-XR6UJyygDUcRqy-nVw426xVfUqroRBacsx8NEo-Sh96YYXZnDd8YJ7w-0mJejPiBmKLNtb2DvbIEjnSQWoo2urGqRVymvnzfUxrgePMDqI1mvr0r6DWEQR3EqFsZgY6LrfR3sE2MoedS23WdJs6VQNVtvY2tiCJfqxreXdYrnxxhQ16SpxuiG-EekHuMi5Kwntfk9WEuAAhjLkWD4twBRNtWuN_-bKqBW4-rvcAN0QgqmEIKnPGv0Wl1pXA6qjaOL2hWmnjXN9fRBQM2DmzoQw6Z-FhFSiwreEV4hrswsGRSa1GWViDkjoW4WB_7MQ",
  "oidc_hash_trailing_bits": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1CIn0.Nr2cLjxgJlLyL8zqRj4nWcabAHRX4Blv6m_WpUiXspVg6tknYGscYLMbXafI940wkBWhXIxjXBNSfKihKD_GWKrKD_Os_7UgSuQJv-BW26rXmrncB2X7KJdfOD179iwwS8i-Pc-IP51xF2soK7bt3Av-BlaRJB8jg2ypHNAw0nbjhsA7-3gAwP3DxHr2aJSRxMP18zgWBha_GmYD-quZzLTnwxvjLioUV_9n08krvcry6qvzktciQqiX8YjmnoRToVxh11Q3VXC0d6jwk0_0kIwrphRkS9d7ouQfxGeVNpnJbPx-XjG8HqdJJen7VOsTM3MQEyetiTScZjxYvn_QIQ",
  "oidc_without_hash": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSJ9.h0e1ae9PF8rP17HNeoYaRNPLbAJAW3i4mR26PgopLyxbO_IDUuzGMo1FqdnzHSxBp8KifLuFjWeH-TxUqwYY7lIpzJONhM1H-uOZ0lXMJQ2sz0Ay-AAaF5l3pF7-bcwEnp2fYQjt4DfQLeLs3XrSC3fNZMZyJ5r4AvKQ6tkJPVTgBbU8VwyccgdqniHC44bi7Tdwh2Y1VVRJWcV0o6Iu_THqBasQLFxbEqwkKrFZUvWsekkOqoNamFKvAhl-cu1rZoqaGfO1-sY4A4UhGkcmVDqYXMPKfN0Dbe4OxnAlEX-eAUCNIlFPNgJEsGhVSQPMd8iIsSqZ1d7hd11_NkOMLg",
  "oidc_without_auth_time": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwibm9uY2UiOiJvaWRjLWZsb3ctbm9uY2UiLCJhdF9oYXNoIjoicUlCQ19adFRZWHUyRWx2OTlEOUMtQSJ9.cXGqK-PwuFL73q6VIlEfr0Wqh-lXOt_ql05Ujch75PiD6_z3MyYiyGaUB6kvwKjlpxMFXiE3BQGRYFaIXpbzFcPVaxJ90aSCLlfPaZ-q6aIT3BdTEEWQZidiPs2RZxIKlHLS2dRrKtoLF0jL0WZz0KhVXBIJKyun9Y83YDHXA3scH3YyFoBg8u5U7eXcJgNDBk6YJEEtMbSUznhaAbkZIrUzpbRAcRa_WaIbz_XMBwqMjYbWi235qvuLtAnjG1JXQtdb8EY4yNSr4YZaqyTYswP0khzMZBLThivf2oH3E8AI6UGyPG3Cqamj4Cats1OpRlY2sLrCgWKIvtoyYSK8JA",
  "oidc_future_auth_time": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAxLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIn0.c0jPBKK4m_RxnlbozairRLqRGLXrgA6zMb29zdPrI-4cK9QQxkxKX6HA2X_XPGcfg4g8cJg81HVOEc5Q4yQ_LZ_q8jxrDsjeR5uWUARPONU9DPCI6p3pfEyhV_LvW0yRADyeMno6JkdsN47UUtdyKhGKTrLQw_P-6ug-_jtqI1DPsmT2hC3rB3YokKZOIJbi5p-_WvEB6uJZu_ffpFAcIXGcVMOiijJ8zCZa6TuJz8on5pCjoz3MpxcKLdUvC23BRUicvq1XTl50qNi1WjgDFJSyio_5wxrmbA6vvYYsf1ciRRrQMcM_tbuBZUCJT4yFQBxjHjpZvJ9XxWMWOrEzog",
  "oidc_fraction_time": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAuMDAwMDAwMDAxLCJleHAiOjIwMDAwMDAyNDAuMDAwMDAwMDAxLCJhdXRoX3RpbWUiOjIwMDAwMDAwMDAsIm5vbmNlIjoib2lkYy1mbG93LW5vbmNlIiwiYXRfaGFzaCI6InFJQkNfWnRUWVh1MkVsdjk5RDlDLUEifQ.aN7MDasnuwq5BBcTcim4pQ0vcCnjyvkZY01qZYWnXOPrCsVWOMlEZEVwPOFrAX8DLasYFTjIpmU-fL6oliPVU2zugYOY95kK5BbHkZeyJ1rSJS6CN4iBBbbdojGWWpUwolbn89ScXRMD7oZutZEt9TUZWnTpr03FwjMN9uQQ_c0pDc5E3tVdsxYxvvkJ78xs6p0utNHw2Df3zeWLL_GlD61JSA10tZxFRarT799wwJhLmnC8njYBbjswS38b3rvHPJeEQSReTb9qmr-UStBs8w894eVNCz82APoBDwzts9QEW95xxIC1VTN-nOzxhUXhHljH7FMSg2omGp8QjxEu4Q",
  "oidc_exponent_time": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjJlOSwiZXhwIjoyMDAwMDAwMjRlMSwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIn0.c_vh2D19JqQbzTXu6aw-2SfEOXrt31MsLIRwHezyOgKEm0brm9xanQOOWj0cfFvD42DtsWIIR94_I_Nswg_umrZPSZuL3FoPKw6oB7Vg_CqXsY3WlKvDMDpjGGsmbLtPnZ_g7N7uvF518J7blngMFgaTB5sUfJgGr-Ia1YCe0pbA7XBKdlpSCf7QrppXWqZe1m_7UHxvxdYXQj2tvliCk9G54TAGHMgYvvNULO4ShcfhBKwmP3TF8M6CdoAw-gLpEbKR9KUwllMXeJcOrICiRGfpC3SUFxArRwIkyOw7cBSN2320wUWV_mN8sZhsK4m87PoCL0T9S7-j0RTpIoh20w",
  "oidc_bad_precision": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAuMDAwMDAwMDAwMSwiZXhwIjoyMDAwMDAwMjQwLCJhdXRoX3RpbWUiOjIwMDAwMDAwMDAsIm5vbmNlIjoib2lkYy1mbG93LW5vbmNlIiwiYXRfaGFzaCI6InFJQkNfWnRUWVh1MkVsdjk5RDlDLUEifQ.JuHQDHYPUvWl4Wz7sTaNvL5Dv5NB71Gcn1X62LDSOkHgOe9XqfZ-GRq0kpXa40f7_4sQrgTwPMoKG5d_SrZXeXGLmpVu9H6pV0Y6Lwq6SFGX2ADFaxfIxqQCg0SYd4juZIFCVA5T8mR0winJ9ACMX9TNfTL-Umxujcs0BiE3KkFeIE2FsRCDIP6pmQqBzouD7jntWRt1_pZQm7K0gnWINHAui3Qh-QIylCkFrpciKTd3dwn89oIrbEy7u0ECYGIwNttwobDR3cJ5y6mdYB8EzRD4-_O6phqViOsF30WiJx2SZEfUEoLiTN9dvS2I53WFFbMotODeT5KZCNA5Af128w",
  "oidc_negative_zero": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOi0wLCJleHAiOjIwMDAwMDAyNDAsImF1dGhfdGltZSI6MjAwMDAwMDAwMCwibm9uY2UiOiJvaWRjLWZsb3ctbm9uY2UiLCJhdF9oYXNoIjoicUlCQ19adFRZWHUyRWx2OTlEOUMtQSJ9.eYlnjCD9VRj7Notu_U5QkuHcI8NIZI2vIK0A6SGsivCiAK2FAAehl7ZFiilgmYF4XRUBFbCB86_Sz_ILdiKX4bVxTgdPVpVEFA9L3VC9XtySNvk1kmw4NGgQKcuNC4z-m0XMT6yUOHCXSGiJMv_tsSDJaV1FtDQcKS_588fTpqtzOEPTuUWj0pWBCUGzj-p6Xn58xGt_uFILgqHdkFMWBfWJMsoz4EntTVRvdVsj4deuFw7tMDSu9U86VOXzUVZl02IcFnM5PZSUS1E4XSmfK-gdIsivaE_gYO80HaI2T35__t_DMu9JiIYx177l9qRogyVMxDQk59wkIqQQ2x8D_g",
  "oidc_subject_nonascii": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoic3ViamVjdC3DqSIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIn0.K_9wCs0ZDGCTtvtmgCPjOyZHIpDlYlRi1tYsNLZiw1d7-JqW8g8MJLSTBFHrbdTUctLzDPGXSITTMbsPcqT5IX9HAUpwepSfI_UdpQBaRVJZXIATJlO8ERT9FNNvj5nJHNaMrTsTOXV9CdurizJJSKY7tygBmNknLRtFJRBjHXAQm0C0K4jCWC2oUK_XeEPDuSMsAByYkkN2Cf6rWKG659hc_f2by8xUBliw4-nfcqrRWqYOKdoSqQCDc8uxH6pqyMUEAmkP-W-1a8nbVAxjFxrScjapHSRfhANyTQTDwqLfb0gyHKJWWfPXm5tZDOFGOIZPRUHw60xk1o4Pkps5tA",
  "oidc_duplicate_claim": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsIm5vbmNlIjoib2lkYy1mbG93LW5vbmNlIiwiYXRfaGFzaCI6InFJQkNfWnRUWVh1MkVsdjk5RDlDLUEifQ.lUT4puRufoJWE2TuXtwu5jVew3Oq5-AZFama02QYaBiokKCDTCCzd1zCNywoK-dtJ1KY8KhFZCcuXyCQoL4Sfy8Iio4OZU85MmZsnZ0EbcCSKjBUinX1ZNRQY5vG3sPomPoIB16RpvbTOGd6nFotzSTmEwzG4yxtKaElmkbVPEg0cqfM_8n6VxISgR09y0Wd9YRk-SKBTiX_Cxe_KIDfYUM38FQHgLPKv1ofs7sgM1JSr24AYaij72SC81wWsdEfNqseDLDyhx-vbgwidj3el01W9yYwfBsavoIpq5LpaQKQdhK0GkxOBqUNwjfqwDByR3Q16Dx-OtwlP27inmRGdQ",
  "oidc_nested_type": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIn0.nLpye2WVeUKzOZ-C9Nwzwo4YbplgANT_BrXyRKy7B-WVlr82D0zt3J-eUwOBYT_-20J74u8olGJl43AsQY2dBLMH_nJ970MMVPqos-ap6z_1JVTOimX_bzrtK7IACp_Auc00oi_r4uVOoJH3yZohE9-Ot9NnqqeoVHNLrhGlo5t3m0V75ZXdJi7SeovYPVpm3ABZUC9FpnwgNHPiX10AnFu6KcScE3UY1sVyhq7d02NykfQhcRDZGAHE2t6fHtqfYlv5KUI1C6I9gDggQF__Csm5OiBpRlwbyx-eDGSZM_oqkCeNz_NKi8bUEYPCSB6j0HxVQrBtkMQ8RR5Vb-SUyw",
  "oidc_remote_key": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsImprdSI6Imh0dHBzOi8vdW50cnVzdGVkLmV4YW1wbGUvandrcyJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIn0.EbGqzw33h4EE85WUi5S7-AkEt5m7JcnACJGd8FGUZKIfbY8dkLH2qVzfVQPjrwEMybX5YWcNSrC_Uh0Qzo8X8ja0wefxvoue-EJU_mYMM7Vn0o5FcmlXiD7Kv5_Pe7wJ49ysoDz7V1-Xpv0MGK6362fZMkTqXmMG2YRu8bUlGVXK75ylKsg_xuKPWuvRkZ6G3c4yjBJq--8HUajqm489_0D5yelzNZC6QrVWp4FTRlHt9sJL83KEcofp9PfU_ZwP8L2JhPQV4nGdVir6mIKpQ22uRrtFhf5fCgO-D7VG0c-sV6tAqFUW8WHO-3pPCxWh9V7mO4jCO4oQILDMIkgBUg",
  "oidc_unknown_key": "eyJhbGciOiJSUzI1NiIsImtpZCI6InVudHJ1c3RlZCJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIn0.GbgfVJyMOulBBvVVMGhoxMD2uHFRqJNYsJrlWHFBXGVUF-4dVVxNLwMTO5Eh4We0QkTLdPRn6Azd6aU_4C1jl2mqAYGooKTTmf0MX1IXpnUclLv02Qib8Ewo7sAaLS82iO1Wf-slDSuPxLQi1hvZdBNy9AEC0tEX3wydRf5ROpH4wtywZRySbrKXbYPzTFbdYp9ZJnJUfL11IE1Rip2OEapj0_mj2razMWkARMYCCOJY83ZJ-tsasvrkJgfPiiMiyiPDc0rTxvhnurB1befI5KccfMKJaMvq6cF0va0FJSASCuiaBUhlW5fBynvgfBIml_yfrVO4-1jIvkJlxDBoGQ",
  "oidc_foreign_issuer": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2ZvcmVpZ24uZXhhbXBsZSIsInN1YiI6ImNsaWVudC1mYWNpbmciLCJhdWQiOiJuYXRpdmUtaWRwIiwiaWF0IjoyMDAwMDAwMDAwLCJleHAiOjIwMDAwMDAyNDAsImF1dGhfdGltZSI6MjAwMDAwMDAwMCwibm9uY2UiOiJvaWRjLWZsb3ctbm9uY2UiLCJhdF9oYXNoIjoicUlCQ19adFRZWHUyRWx2OTlEOUMtQSJ9.TjulZtWJDXv4jxdaouA_UT-txtMhvG-Edb-DS79fX4OTKLqKMKYXJMiD521osbSv-3MHGCDi6AnP3ESmjnW62xezThExACv0yme2r3BxPtvh4ASXT_9YmB-SY01xrBDGYNOfcbg8LvqrOW3WWnKSxJ2ElcCWXBGmxZE7oqDpjSgEJLrIulQmN3xju0w4Ba8VPqTebT6l1KoaxvELKgMFEaYvta-yncqDGiNTs8SgdMccJHyJjLhbWuPO88_sryD-r5fqwunli4SwewnGuCSyyi3f4PNz7pt3aUGJ_TVD4bLUI1mWSzs_o0nnPo1j1q-ty070DSW2Ef1vXKVa_TREIA",
  "oidc_not_before": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoiY2xpZW50LWZhY2luZyIsImF1ZCI6Im5hdGl2ZS1pZHAiLCJpYXQiOjIwMDAwMDAwMDAsImV4cCI6MjAwMDAwMDI0MCwiYXV0aF90aW1lIjoyMDAwMDAwMDAwLCJub25jZSI6Im9pZGMtZmxvdy1ub25jZSIsImF0X2hhc2giOiJxSUJDX1p0VFlYdTJFbHY5OUQ5Qy1BIiwibmJmIjoyMDAwMDAwMTIwfQ.SCp2QbLXqzzpqjz7gJivCCKIymzNn6NAbQK3Ykb0GV-rcX5eyPdIJAKf16XD72igaP--6Ew04CMLsYVDPoHNS_Y7F4yGBFGs1r7mCjqcj13MjHO7cSOYexCUF74wyFBCxSX5MljGVCbGBJhwvBkXsN79mNJXz4peTKTcHmiaqglTC7kq7CNdVQFpfWXuvzA_V-wzIgr7Y0E9fTzyuJm2JyK8pO3adkBBz8ppoAakwdCRZ4vLDlfhuLBSUt1eRYyo7dHxLCFW9XWMGATrN5bau4MsTqABGRhXibx_tsvr5IE9Uj4Ntj2eK1FSiflhrWowiNO3PsOCIHtpYqft51_dPg",
  "id_jag_singleton": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6IkFwcGxpY2F0aW9uL09BVVRILUlELUpBRytKV1QifQ.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjpbImh0dHBzOi8vYXMuZXhhbXBsZSJdLCJjbGllbnRfaWQiOiJuYXRpdmUtcmVzb3VyY2UiLCJqdGkiOiJpZC1qYWctZmxvdy0xIiwiaWF0IjoyMDAwMDAwMDAwLCJleHAiOjIwMDAwMDAyNDAsInJlc291cmNlIjpbImh0dHBzOi8vbWNwLmV4YW1wbGUvbWNwIl0sInNjb3BlIjoicmVhZCJ9.cJPWUlxazx3WRiyWJcIEu45g_tELCCTOOkXEVkkIIpB8orgiTA_TI-923PwH7LTA-PXJemU8Sie1zIw8IcmO6OiauOVcKztlm1g0yNKd7cCEs02zCl6EnVpZLBsc8sz8Gs9oMNYEMCJ4V4KJdBxreCn__7U9-Z2aI3pp_SHcmcSfldUB9nbJfNXbDi4NHLVoZaB-a6KuH1HGZIK6RpnjRgN0o3eNnNMv0aIVJyASCwr77QMtHhPCnCSDn2QnmTRi6c6QZ1gWaWPt1RWpXVVXiDdZ_z-c4bU7yOShEI_hoCNDogagaIUWI6_07mpWCdVX7jTkRK7sd8DH0rN4cAvToQ",
  "id_jag_multi_resource": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6Im9hdXRoLWlkLWphZytqd3QifQ.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjoiaHR0cHM6Ly9hcy5leGFtcGxlIiwiY2xpZW50X2lkIjoibmF0aXZlLXJlc291cmNlIiwianRpIjoiaWQtamFnLWZsb3ctMSIsImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJyZXNvdXJjZSI6WyJodHRwczovL21jcC5leGFtcGxlL21jcCIsImh0dHBzOi8vbWNwLmV4YW1wbGUvb3RoZXIiXSwic2NvcGUiOiJyZWFkIn0.ZQarXy-yI0rJtI4ncwJNZjwISjOb9ChBLk71izUeqVY65Lk6Fig_WF4-6b573MmqtFjbHWXMzQXvyEXxhPP_w0rvbnlbfJ5OaYVJKPFUK32QrD_q6RqZARHcqmlus3X4HeOycGtKLl6fQghDaBTIA8EO9swsR8YnRjAnxULFB_r0zcxM8XQg40De6wQt1GIrUATpIRuRKphtp5_6ZIR4mkUjIb9LgNJP2OARqP7oGvcg1y_6ux10UzhA-QCZg6dygkAXDj3j5yl1BzXYT9mkvuM0SzzygjhHsT6Bo2kz3FvyaS0hiTUK2RwUlNM1_81xx2Tha4V1LIPOJyOpuBvKJQ",
  "id_jag_multi_audience": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6Im9hdXRoLWlkLWphZytqd3QifQ.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjpbImh0dHBzOi8vYXMuZXhhbXBsZSIsImh0dHBzOi8vb3RoZXIuZXhhbXBsZSJdLCJjbGllbnRfaWQiOiJuYXRpdmUtcmVzb3VyY2UiLCJqdGkiOiJpZC1qYWctZmxvdy0xIiwiaWF0IjoyMDAwMDAwMDAwLCJleHAiOjIwMDAwMDAyNDAsInJlc291cmNlIjoiaHR0cHM6Ly9tY3AuZXhhbXBsZS9tY3AiLCJzY29wZSI6InJlYWQifQ.FpR0Mfm7MNzAt4LZd9gj_C0DSh0S7EXcKr9tNHoIpUAVVwkmnOcXIyeyf0t1bCjZHCwpp7K3L35RIdAfLSc2zfFyj5bh2qDG1IKc3ObAcXYsCWRsP0xT9nsacP-W41-eCAgOVHCTW28EReZPceCArZQo27aw53BHoIbmOpiOdeTbiCEHMZ8R4CgWbIWqm1Uhvpw-7B2SG3v-r943LLoHslUin9jBgfkRnu29MP0wlLAnq9jDRrtMQE0V1UWR2lkwVHSts8OB0CGUmSmZe5GVi3CilFFQQrrfwdFLlJgk82xZ2iiipnJApOgMEDLQ6UGDvsGkj6aMRQUdHcXXq8Wysg",
  "id_jag_missing_resource": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6Im9hdXRoLWlkLWphZytqd3QifQ.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjoiaHR0cHM6Ly9hcy5leGFtcGxlIiwiY2xpZW50X2lkIjoibmF0aXZlLXJlc291cmNlIiwianRpIjoiaWQtamFnLWZsb3ctMSIsImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJzY29wZSI6InJlYWQifQ.HyKhLBwE4iJ0w4BogGeMFyWZMIk1j5kR1f2tyghg2OLvOFDzAvmPtLTQDYhVEucBuktuuvZMx_L5wzFM7dkXItPJyDsKIaQpNMoKVBwXdKYKPP18ohkVYte_PZe0LZk-q16pI9csKp_Rvs47h2WES3pUc4ywpqLsOgnzPWTwlCpp0KJ0BRYmNlYCmxG9uSLibDnhxgn2HxQC5pCrJPhhjNnVLuGQFo6rlSaQ6dfB3EJZCJfNDpJ2ByoQll4P96jQU3f-KjuFtIGXI3hMzVkukGkaS_RiExsF_W3Rn9zjYGWkgG0XKiS0oP4xVyUGdcicF3Yjpby5t2IlEnlu1Br8ww",
  "id_jag_missing_scope": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6Im9hdXRoLWlkLWphZytqd3QifQ.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjoiaHR0cHM6Ly9hcy5leGFtcGxlIiwiY2xpZW50X2lkIjoibmF0aXZlLXJlc291cmNlIiwianRpIjoiaWQtamFnLWZsb3ctMSIsImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJyZXNvdXJjZSI6Imh0dHBzOi8vbWNwLmV4YW1wbGUvbWNwIn0.EQXDExx3cTNuPp3DozxZvdRIgx9khETs0e1d3O1zXjypkIDVqCUu1DZ-Td7Dbr60Prdzqhw8oX5Femslpiag3s6UHIaLgbbi0ZbALdbIa_CKhFIm6qxWT1M8Uwx1ek5D5LPAiiJRi8fsExUzphl3-wKMa3U5STW4Glh3WJOl9xGg_-m26cZF9myU2H0X8gC9KtlDJh6tU-uzyn4XaVCjt6dcw6DYe03hvTdk3h3ocJKSxmvkasdtRJCQuBmf0cJpA6IuuMUiPjeXgdDx3LQxIpL4MEzi5xcCUUM8rz8B1oNOx7FhF43U285PEoFaEqj6BXxwNCv_8JKkFmlXipIhQg",
  "id_jag_duplicate_scope": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6Im9hdXRoLWlkLWphZytqd3QifQ.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjoiaHR0cHM6Ly9hcy5leGFtcGxlIiwiY2xpZW50X2lkIjoibmF0aXZlLXJlc291cmNlIiwianRpIjoiaWQtamFnLWZsb3ctMSIsImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJyZXNvdXJjZSI6Imh0dHBzOi8vbWNwLmV4YW1wbGUvbWNwIiwic2NvcGUiOiJyZWFkIHJlYWQifQ.Oqc7ooR_5EAF_CKJUWxX3cz6vQI1SxWHFoQ8dn_AQVuM-jEoeeY5NQO_mztkQwIf8VJFgtpXwHuPpP3w7C4sbPcj_F80mthzyByw1NHT0BDPFcFSlYerlCOhHXin1PLlKNE5wid-NaylnGqA7oSn5RmIjnC2LTRr_DtDD2KZ2zNth_Qmmp29N6TcZkUFxS8_uk-lnxFWROjEB2VqeY8bQFAM5kYcjU0baosp1LwR6lN7wIw7boBlEZpEfn8J0wHyFThsVgtryI6erFrEJ9kOJ4GiZNWudVdBqa__lWpOy6GWvdVwGO1bHp9jLvJWnGuqYygJg4XYpCUqS4e3l14UEw",
  "id_jag_tenants": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6Im9hdXRoLWlkLWphZytqd3QifQ.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjoiaHR0cHM6Ly9hcy5leGFtcGxlIiwiY2xpZW50X2lkIjoibmF0aXZlLXJlc291cmNlIiwianRpIjoiaWQtamFnLWZsb3ctMSIsImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJyZXNvdXJjZSI6Imh0dHBzOi8vbWNwLmV4YW1wbGUvbWNwIiwic2NvcGUiOiJyZWFkIiwidGVuYW50IjoiaWRwLXRlbmFudCIsImF1ZF90ZW5hbnQiOiJyZXNvdXJjZS10ZW5hbnQiLCJhdWRfc3ViIjoib3BhcXVlL2FjY291bnQifQ.KlmLEfjjXSySC-8cvOdXcZ-MNutykKqAzKz8fcvowbUkRxF5e-KwHZxHfkrdqWot9IkUWHH6m_NvzjewJ6IalVzjP318QkWy9VsYNigWUFNigK8-VOken37I5-xRt7NvPE2zhHphBHY9iAT-xMMJvMhRCa33-VcucE3Se6tAKpE4zw71oKlc3R2zjlP7CppScypRHyv4zzrIeD2NlVz4WPqlqWYusp-oNIOOijdZuqXyDZPuUyf02uxeCDWPqY06Jx3kap0ql2Rrk8YBs-0BApSiYVvf39puvdZ3gizkvXJ43Rr_qGiwZVRW-XohsfRjwedFe9xE1rMErGiJt9nl0g",
  "id_jag_tenant_missing_subject": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6Im9hdXRoLWlkLWphZytqd3QifQ.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjoiaHR0cHM6Ly9hcy5leGFtcGxlIiwiY2xpZW50X2lkIjoibmF0aXZlLXJlc291cmNlIiwianRpIjoiaWQtamFnLWZsb3ctMSIsImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJyZXNvdXJjZSI6Imh0dHBzOi8vbWNwLmV4YW1wbGUvbWNwIiwic2NvcGUiOiJyZWFkIiwidGVuYW50IjoiaWRwLXRlbmFudCIsImF1ZF90ZW5hbnQiOiJyZXNvdXJjZS10ZW5hbnQifQ.eAf5t9oxLYps1KaXdpmz515T_YWMZVp0bfF24x2bVYB2utYhqPY5EqNFKV0VtBZj1t9KCguGGjj_nwqOZQqjHo81faCuPjHzUcAtM8Ci6XMLXiDFcRO2hu7OaUpFKFrXh_gXzahBOAUitMeHv_JUIKeWyZTSZ9QrWs6cVL4UcnCWIDBDZKdULrrBtgz-moZHLJvhtRwzFw07Pk9suhU2S0HLe0nLymj95tFUWO__Ag1kOrquNoaabNmAZIlkg4CWsHuaYC-JcJMsvs_rxL-NFN6Xa-WLKuE_Spjdaqj58-cdmdAOVc-iM7FGpqCSStbpQKeW8ialivYQIXr0PqtKNA",
  "id_jag_missing_type": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjoiaHR0cHM6Ly9hcy5leGFtcGxlIiwiY2xpZW50X2lkIjoibmF0aXZlLXJlc291cmNlIiwianRpIjoiaWQtamFnLWZsb3ctMSIsImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJyZXNvdXJjZSI6Imh0dHBzOi8vbWNwLmV4YW1wbGUvbWNwIiwic2NvcGUiOiJyZWFkIn0.CzUTe9gZEd-RbpbkZDwJRV9z_JL3Q0Sy2WHPvcLSW0plm4tvYtivAhGPa4Xxg5SfNI_QUbT30wAP7BKnTh4Q8zmumXZ52RNWSdOZ5Zi2JNZcLXCHKRkEF8Sukwo_xzxW3ZPVC5VbGghMJGRQaxFYt3DHmmt19dQOXN-B40G3FqffGpLKtvYfalSxh0EuYB0IJ6KpJz2PnrCCuhR1fUwV9HqqTTDSUi-IXBIe6CqIao8N1BdAzWqpyrhS9CnXKDk6BFPKIinycxi6OhRki5yaM7yP7fSNnT0DWoDuYmWAOukrQuQWnraCBjia7e_WIBx-iBIBVP70eXRABWA2eIN9VA",
  "id_jag_oidc_type": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjoiaHR0cHM6Ly9hcy5leGFtcGxlIiwiY2xpZW50X2lkIjoibmF0aXZlLXJlc291cmNlIiwianRpIjoiaWQtamFnLWZsb3ctMSIsImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJyZXNvdXJjZSI6Imh0dHBzOi8vbWNwLmV4YW1wbGUvbWNwIiwic2NvcGUiOiJyZWFkIn0.eXVautZPQiW97kpcqDcLEGC29g4gKQ6v8G-pDR5Boh2-egxxm27XN2zLCKDtysuYzYqbT5tmRf3HnL-e3DTjkoFJweyeEhbF0ytYLeqGecAMBFkln1hgwgMnhbudW6EWwDTHIeMZyfAQ1Bk7N2-eXfApt7_No2n_0y4ubVed-boTgplkrUrCn7CaVyPE0XMW7CrkW_2146fVrfLDjT9sJgl2MTHZ4x3Vgb1mB3lrFOP7tY1yBNSD_iwVsyhbk3enriwDR2b78JcH5q-_eEprIKYdbaoH2DZ8l7QlesDjwRj6GW-uxkunnvFrriBD74nUNtV4lBpAemp6FZhGzfKJEQ",
  "id_jag_forbidden_cnf": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6Im9hdXRoLWlkLWphZytqd3QifQ.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjoiaHR0cHM6Ly9hcy5leGFtcGxlIiwiY2xpZW50X2lkIjoibmF0aXZlLXJlc291cmNlIiwianRpIjoiaWQtamFnLWZsb3ctMSIsImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJyZXNvdXJjZSI6Imh0dHBzOi8vbWNwLmV4YW1wbGUvbWNwIiwic2NvcGUiOiJyZWFkIiwiY25mIjp7ImprdCI6InVudXNlZCJ9fQ.gUyLNnlh5hyJfNYjfpz07ETW4mnCcNA3CWkNf5uKcB-r9iQOY-U4tgEpyJ671jWdONMI12mcTSyaKyJg_OB9BvLerXZ-uPz-oZ4BejfYbA5F71kDgZSczbhjqLCcVMl-dUGbVlC3qaNJSRUuvWqZW-Ado1M3c0mcts0d7RK3i5265R8cUZWutA1nryyiQJLpSQ35HaWc49B_Ag105egNXreatpTGiAf7-yNEFNhCioJqTc1XWqMpLsTGbI5BJPckXvd0Wtp3rfpnE3kXu-JP50LL6AKUnmi7P4T7lhdaLwZbPD-lsBF8hf18Y-ywU3GY-0mRZxw55v3jMoEJ5VDAWQ",
  "id_jag_forbidden_actor": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6Im9hdXRoLWlkLWphZytqd3QifQ.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjoiaHR0cHM6Ly9hcy5leGFtcGxlIiwiY2xpZW50X2lkIjoibmF0aXZlLXJlc291cmNlIiwianRpIjoiaWQtamFnLWZsb3ctMSIsImlhdCI6MjAwMDAwMDAwMCwiZXhwIjoyMDAwMDAwMjQwLCJyZXNvdXJjZSI6Imh0dHBzOi8vbWNwLmV4YW1wbGUvbWNwIiwic2NvcGUiOiJyZWFkIiwiYWN0Ijp7InN1YiI6ImFjdG9yIn19.EYVW92XeRcXeKAQYU53mDkFIQkVMyrPJbgWor4H_knUvDNY-a408AFyto0kITpg5JaiQWMhurJzTxS9MKLSWuWp6-SrtlS7K38P299a6nndA4tFZZ6YFougFAUKuON81n66bdrS-4bRm5OwuOHhXa2C7Gbqld3Fif_qGo9RoxcVgBxjgD2hjEbiS12dfa2VBZmTb6V44C7aIaPkqBpNgFOG9SADsLQyOs4ArCweoo2oRbafBcJ71nYPQpJviV-Li71Fq60N3IEdXIyt-KdsYYeBuHdZuG79lpswf082Yp6NfDNQ0naSLEhzSNVCVb798jD8DakXFs72dF7kzkrwcow",
  "id_jag_empty_jti": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImVudGVycHJpc2UtcmZjNzUxNSIsInR5cCI6Im9hdXRoLWlkLWphZytqd3QifQ.eyJpc3MiOiJodHRwczovL2lkcC5leGFtcGxlIiwic3ViIjoicmVzb3VyY2UtZmFjaW5nIiwiYXVkIjoiaHR0cHM6Ly9hcy5leGFtcGxlIiwiY2xpZW50X2lkIjoibmF0aXZlLXJlc291cmNlIiwianRpIjoiIiwiaWF0IjoyMDAwMDAwMDAwLCJleHAiOjIwMDAwMDAyNDAsInJlc291cmNlIjoiaHR0cHM6Ly9tY3AuZXhhbXBsZS9tY3AiLCJzY29wZSI6InJlYWQifQ.Es7o_cSWSgbOJZFsoglIDQMCygErKKXIP4AJRtTpO4dYeWTqWApqKs6rCSnMjfsL3XtIo4tHnp4oeJbulcopTW_-qrEDmchDSiAmmHWJ2HSncpXLh7NtXXF4zpmsco54G8-xPP2L2b_fj_Fq3JTO-lK4Epkz-Z8wrfoJQMyDY9PgugxlYbxLbNyoQSHE1jmPnLwUYeUhlarzZxQDLDsPzTXxLs6r0bhV6Z6VMjxOTl3HK9o089FMkqKnqAdwy2kLbFHQe4vLg2g4rcLTD2AJsLt8oMVpsJNxts6EskMZuuDqDbEsDFJHIu8tXIFSJPxLajNyRzeN5TPmTbmuWE3IPQ"
}
"#;