1use std::collections::{BTreeMap, BTreeSet};
39use std::fmt;
40use std::sync::Arc;
41
42use serde::{Deserialize, Deserializer, Serialize, Serializer};
43
44use crate::audit::RoleName;
45use crate::auth::AuthContext;
46use crate::identity::Principal;
47
48pub const ADMIN: &str = "admin";
51
52pub const CEILING_KEY: &str = "ceiling";
57
58#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
65#[serde(transparent)]
66pub struct Grant(String);
67
68impl Grant {
69 pub fn new(path: impl Into<String>) -> Self {
72 Self(path.into())
73 }
74
75 pub fn of(activation: &str, method: &str) -> Self {
77 Self(format!("{activation}.{method}"))
78 }
79
80 pub fn as_str(&self) -> &str {
82 &self.0
83 }
84}
85
86impl fmt::Display for Grant {
87 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
88 f.write_str(&self.0)
89 }
90}
91
92#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
102pub enum ScopeRef {
103 Everywhere,
105 Named(String),
107}
108
109impl ScopeRef {
110 pub fn parse(text: &str) -> Self {
112 match text.trim() {
113 "*" => Self::Everywhere,
114 other => Self::Named(other.to_string()),
115 }
116 }
117
118 pub fn named(name: impl Into<String>) -> Self {
120 Self::Named(name.into())
121 }
122
123 pub fn as_str(&self) -> &str {
125 match self {
126 Self::Everywhere => "*",
127 Self::Named(n) => n,
128 }
129 }
130
131 pub fn is_everywhere(&self) -> bool {
133 matches!(self, Self::Everywhere)
134 }
135}
136
137impl fmt::Display for ScopeRef {
138 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
139 f.write_str(self.as_str())
140 }
141}
142
143impl Serialize for ScopeRef {
144 fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
145 s.serialize_str(self.as_str())
146 }
147}
148
149impl<'de> Deserialize<'de> for ScopeRef {
150 fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
151 let s = String::deserialize(d)?;
152 Ok(Self::parse(&s))
153 }
154}
155
156#[derive(Debug, Clone, PartialEq, Eq)]
162pub enum GrantSet {
163 All,
165 Listed(BTreeSet<Grant>),
167}
168
169impl GrantSet {
170 pub fn contains(&self, grant: &Grant) -> bool {
172 match self {
173 Self::All => true,
174 Self::Listed(set) => set.contains(grant),
175 }
176 }
177
178 pub fn listed<I, G>(grants: I) -> Self
180 where
181 I: IntoIterator<Item = G>,
182 G: Into<String>,
183 {
184 Self::Listed(grants.into_iter().map(|g| Grant::new(g)).collect())
185 }
186}
187
188#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
191pub enum RoleOrGrant {
192 Role(RoleName),
193 Grant(Grant),
194}
195
196impl RoleOrGrant {
197 pub fn parse(text: &str) -> Self {
199 let t = text.trim();
200 if t.contains('.') {
201 Self::Grant(Grant::new(t))
202 } else {
203 Self::Role(RoleName::new(t))
204 }
205 }
206}
207
208impl fmt::Display for RoleOrGrant {
209 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
210 match self {
211 Self::Role(r) => write!(f, "{r}"),
212 Self::Grant(g) => write!(f, "{g}"),
213 }
214 }
215}
216
217#[derive(Debug, Clone, PartialEq, Eq)]
219pub struct Membership {
220 pub principal: Principal,
221 pub role: RoleName,
222 pub scope: ScopeRef,
223}
224
225#[derive(Debug, Clone, PartialEq, Eq, Default)]
230pub struct Ceiling(pub Vec<(RoleOrGrant, ScopeRef)>);
231
232#[derive(Debug, Clone, PartialEq, Eq)]
234pub struct CeilingError(pub String);
235
236impl fmt::Display for CeilingError {
237 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
238 f.write_str(&self.0)
239 }
240}
241
242impl std::error::Error for CeilingError {}
243
244impl Ceiling {
245 pub fn entry(text: &str) -> Result<(RoleOrGrant, ScopeRef), CeilingError> {
247 let (left, scope) = text
248 .trim()
249 .split_once('@')
250 .ok_or_else(|| CeilingError(format!("`{}` is not role@SCOPE or grant@SCOPE", text.trim())))?;
251 if left.trim().is_empty() || scope.trim().is_empty() {
252 return Err(CeilingError(format!("`{}` is not role@SCOPE or grant@SCOPE", text.trim())));
253 }
254 Ok((RoleOrGrant::parse(left), ScopeRef::parse(scope)))
255 }
256
257 pub fn parse<I, S>(entries: I) -> Result<Self, CeilingError>
259 where
260 I: IntoIterator<Item = S>,
261 S: AsRef<str>,
262 {
263 entries
264 .into_iter()
265 .map(|e| Self::entry(e.as_ref()))
266 .collect::<Result<Vec<_>, _>>()
267 .map(Ceiling)
268 }
269
270 pub fn text(&self) -> Vec<String> {
272 self.0.iter().map(|(rg, s)| format!("{rg}@{s}")).collect()
273 }
274
275 pub fn layers_of(ctx: &AuthContext) -> Result<Vec<Ceiling>, CeilingError> {
280 let Some(v) = ctx.metadata.get(CEILING_KEY) else {
281 return Ok(Vec::new());
282 };
283 let unreadable = || CeilingError("this session's ceiling cannot be read: sign in again".into());
284 let items = v.as_array().ok_or_else(unreadable)?;
285 if items.iter().all(|i| i.is_string()) {
286 let texts: Vec<&str> = items.iter().filter_map(|i| i.as_str()).collect();
287 return Ok(vec![Self::parse(texts).map_err(|_| unreadable())?]);
288 }
289 items
290 .iter()
291 .map(|layer| {
292 let entries = layer.as_array().ok_or_else(unreadable)?;
293 let texts = entries
294 .iter()
295 .map(|e| e.as_str().ok_or_else(unreadable))
296 .collect::<Result<Vec<_>, _>>()?;
297 Self::parse(texts).map_err(|_| unreadable())
298 })
299 .collect()
300 }
301}
302
303pub trait Memberships: Send + Sync {
310 fn held(&self, who: &Principal) -> Vec<Membership>;
311
312 fn own_held(&self, who: &Principal) -> Vec<Membership> {
318 self.held(who)
319 }
320}
321
322pub trait Roles: Send + Sync {
325 fn grants(&self, role: &RoleName) -> Option<GrantSet>;
328
329 fn names(&self) -> Vec<RoleName> {
333 Vec::new()
334 }
335}
336
337pub trait Resolve: Send + Sync {
339 fn chain(&self, target: &str) -> Option<Vec<ScopeRef>>;
351}
352
353#[derive(Debug, Clone, PartialEq, Eq)]
359pub enum RoleTableError {
360 UnknownRole { role: String, includes: String },
364}
365
366impl fmt::Display for RoleTableError {
367 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
368 match self {
369 Self::UnknownRole { role, includes } => write!(
370 f,
371 "role {role} includes {includes}, which is not defined before it"
372 ),
373 }
374 }
375}
376
377impl std::error::Error for RoleTableError {}
378
379#[derive(Debug, Clone, Default)]
394pub struct RoleTable {
395 roles: BTreeMap<RoleName, GrantSet>,
396}
397
398impl RoleTable {
399 pub fn new() -> Self {
401 Self::default()
402 }
403
404 pub fn define<I, S>(mut self, role: &str, entries: I) -> Result<Self, RoleTableError>
409 where
410 I: IntoIterator<Item = S>,
411 S: AsRef<str>,
412 {
413 let name = RoleName::new(role);
414 let mut set = match self.roles.remove(&name) {
415 Some(GrantSet::Listed(s)) => s,
416 Some(GrantSet::All) => {
417 self.roles.insert(name, GrantSet::All);
418 return Ok(self);
419 }
420 None => BTreeSet::new(),
421 };
422 let mut all = name.as_str() == ADMIN;
423 for entry in entries {
424 let e = entry.as_ref().trim();
425 if e.contains('.') {
426 set.insert(Grant::new(e));
427 continue;
428 }
429 if e == ADMIN {
430 all = true;
431 continue;
432 }
433 match self.roles.get(&RoleName::new(e)) {
434 Some(GrantSet::All) => all = true,
435 Some(GrantSet::Listed(inc)) => set.extend(inc.iter().cloned()),
436 None => {
437 return Err(RoleTableError::UnknownRole { role: role.to_string(), includes: e.to_string() })
438 }
439 }
440 }
441 self.roles.insert(name, if all { GrantSet::All } else { GrantSet::Listed(set) });
442 Ok(self)
443 }
444
445 pub fn set(&mut self, role: &str, grants: GrantSet) {
447 self.roles.insert(RoleName::new(role), grants);
448 }
449
450 pub fn from_lists<'a, I, G>(lists: I) -> Self
453 where
454 I: IntoIterator<Item = (&'a str, G)>,
455 G: IntoIterator,
456 G::Item: AsRef<str>,
457 {
458 let mut table = Self::new();
459 for (role, grants) in lists {
460 let name = RoleName::new(role);
461 let grants: Vec<Grant> = grants.into_iter().map(|g| Grant::new(g.as_ref().trim())).collect();
462 match table.roles.entry(name) {
463 std::collections::btree_map::Entry::Occupied(mut o) => {
464 if let GrantSet::Listed(s) = o.get_mut() {
465 s.extend(grants);
466 }
467 }
468 std::collections::btree_map::Entry::Vacant(v) => {
469 v.insert(if role == ADMIN { GrantSet::All } else { GrantSet::Listed(grants.into_iter().collect()) });
470 }
471 }
472 }
473 table
474 }
475}
476
477impl Roles for RoleTable {
478 fn grants(&self, role: &RoleName) -> Option<GrantSet> {
479 if role.as_str() == ADMIN {
480 return Some(GrantSet::All);
481 }
482 self.roles.get(role).cloned()
483 }
484
485 fn names(&self) -> Vec<RoleName> {
486 self.roles.keys().cloned().collect()
487 }
488}
489
490#[derive(Debug, Clone, PartialEq, Eq)]
496pub enum Refusal {
497 Unauthenticated,
499 MissingGrant {
501 grant: Grant,
503 scope: ScopeRef,
506 roles: Vec<RoleName>,
508 held_on: Vec<ScopeRef>,
510 },
511 Ended {
514 reason: String,
517 },
518}
519
520impl fmt::Display for Refusal {
521 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
522 match self {
523 Self::Unauthenticated => f.write_str("sign in first"),
524 Self::Ended { reason } => f.write_str(reason),
525 Self::MissingGrant { grant, scope, .. } => write!(f, "needs {grant} on {scope}"),
526 }
527 }
528}
529
530impl std::error::Error for Refusal {}
531
532#[derive(Clone)]
546pub struct Reach {
547 held_on: Vec<ScopeRef>,
548 live: Option<Live>,
549}
550
551#[derive(Clone)]
552struct Live {
553 gate: Gate,
554 caller: Option<AuthContext>,
555 grant: Grant,
556}
557
558impl fmt::Debug for Reach {
559 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
560 f.debug_struct("Reach")
561 .field("held_on", &self.held_on)
562 .field("grant", &self.live.as_ref().map(|l| l.grant.as_str()))
563 .finish()
564 }
565}
566
567impl PartialEq for Reach {
568 fn eq(&self, other: &Self) -> bool {
571 self.held_on == other.held_on && self.grant() == other.grant()
572 }
573}
574
575impl Reach {
576 pub fn everywhere() -> Self {
579 Self { held_on: vec![ScopeRef::Everywhere], live: None }
580 }
581
582 pub fn is_everywhere(&self) -> bool {
584 self.held_on.iter().any(ScopeRef::is_everywhere)
585 }
586
587 pub fn is_empty(&self) -> bool {
590 self.held_on.is_empty()
591 }
592
593 pub fn held_on(&self) -> &[ScopeRef] {
595 &self.held_on
596 }
597
598 pub fn grant(&self) -> Option<&Grant> {
600 self.live.as_ref().map(|l| &l.grant)
601 }
602
603 pub fn allows(&self, target: &str) -> bool {
606 match &self.live {
607 None => self.is_everywhere(),
608 Some(l) => l.gate.check(l.caller.as_ref(), &l.grant, Some(target)).is_ok(),
609 }
610 }
611
612 pub fn current(&self) -> Option<Reach> {
615 match &self.live {
616 None => Some(self.clone()),
617 Some(l) => l.gate.check(l.caller.as_ref(), &l.grant, None).ok(),
618 }
619 }
620
621 pub fn covers(&self, chain: &[ScopeRef]) -> bool {
625 self.is_everywhere() || self.held_on.iter().any(|s| chain.contains(s))
626 }
627}
628
629pub trait Liveness: Send + Sync {
639 fn alive(&self, caller: &AuthContext) -> Result<(), String>;
641}
642
643struct GateInner {
644 memberships: Arc<dyn Memberships>,
645 roles: Arc<dyn Roles>,
646 resolve: Arc<dyn Resolve>,
647 liveness: Option<Arc<dyn Liveness>>,
648}
649
650#[derive(Clone)]
655pub struct Gate {
656 inner: Arc<GateInner>,
657}
658
659impl fmt::Debug for Gate {
660 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
661 f.write_str("Gate")
662 }
663}
664
665impl Gate {
666 pub fn new(memberships: Arc<dyn Memberships>, roles: Arc<dyn Roles>, resolve: Arc<dyn Resolve>) -> Self {
668 Self { inner: Arc::new(GateInner { memberships, roles, resolve, liveness: None }) }
669 }
670
671 pub fn with_liveness(self, liveness: Arc<dyn Liveness>) -> Self {
675 let i = &self.inner;
676 Self {
677 inner: Arc::new(GateInner {
678 memberships: i.memberships.clone(),
679 roles: i.roles.clone(),
680 resolve: i.resolve.clone(),
681 liveness: Some(liveness),
682 }),
683 }
684 }
685
686 pub fn alive(&self, caller: &AuthContext) -> Result<(), String> {
690 if caller.principal().is_none() {
691 return Ok(());
692 }
693 if caller.expired() {
694 return Err("your sign-in has expired: sign in again".into());
695 }
696 match &self.inner.liveness {
697 Some(l) => l.alive(caller),
698 None => Ok(()),
699 }
700 }
701
702 pub fn lists(&self, role: &RoleName, grant: &Grant) -> bool {
704 role.as_str() == ADMIN || self.inner.roles.grants(role).is_some_and(|g| g.contains(grant))
705 }
706
707 pub fn roles_listing(&self, grant: &Grant) -> Vec<RoleName> {
709 let mut out: Vec<RoleName> = self
710 .inner
711 .roles
712 .names()
713 .into_iter()
714 .filter(|r| r.as_str() != ADMIN && self.lists(r, grant))
715 .collect();
716 out.push(RoleName::new(ADMIN));
717 out
718 }
719
720 fn entry_allows(&self, entry: &RoleOrGrant, grant: &Grant) -> bool {
722 match entry {
723 RoleOrGrant::Grant(g) => g == grant,
724 RoleOrGrant::Role(r) => self.lists(r, grant),
725 }
726 }
727
728 fn caller_of(caller: Option<&AuthContext>) -> Option<(Principal, Vec<Ceiling>)> {
731 let ctx = caller?;
732 let principal = ctx.principal()?;
733 let layers = Ceiling::layers_of(ctx).unwrap_or_else(|_| vec![Ceiling::default()]);
734 Some((principal, layers))
735 }
736
737 fn within(&self, inner: &ScopeRef, outer: &ScopeRef) -> bool {
739 if outer.is_everywhere() || inner == outer {
740 return true;
741 }
742 match inner {
743 ScopeRef::Everywhere => false,
744 ScopeRef::Named(name) => self.inner.resolve.chain(name).is_some_and(|c| c.contains(outer)),
745 }
746 }
747
748 fn meet(&self, a: Vec<ScopeRef>, b: Vec<ScopeRef>) -> Vec<ScopeRef> {
751 if a.iter().any(ScopeRef::is_everywhere) {
752 return b;
753 }
754 if b.iter().any(ScopeRef::is_everywhere) {
755 return a;
756 }
757 let mut out = BTreeSet::new();
758 for x in &a {
759 for y in &b {
760 if self.within(x, y) {
761 out.insert(x.clone());
762 } else if self.within(y, x) {
763 out.insert(y.clone());
764 }
765 }
766 }
767 out.into_iter().collect()
768 }
769
770 fn normal(scopes: impl IntoIterator<Item = ScopeRef>) -> Vec<ScopeRef> {
772 let set: BTreeSet<ScopeRef> = scopes.into_iter().collect();
773 if set.contains(&ScopeRef::Everywhere) {
774 vec![ScopeRef::Everywhere]
775 } else {
776 set.into_iter().collect()
777 }
778 }
779
780 fn held_on_for(&self, principal: &Principal, layers: &[Ceiling], grant: &Grant) -> Vec<ScopeRef> {
781 let mut acc = Self::normal(
782 self.inner
783 .memberships
784 .held(principal)
785 .into_iter()
786 .filter(|m| self.lists(&m.role, grant))
787 .map(|m| m.scope),
788 );
789 for layer in layers {
790 if acc.is_empty() {
791 break;
792 }
793 let allowed = Self::normal(
794 layer.0.iter().filter(|(rg, _)| self.entry_allows(rg, grant)).map(|(_, s)| s.clone()),
795 );
796 acc = self.meet(acc, allowed);
797 }
798 acc
799 }
800
801 pub fn held_on(&self, caller: &AuthContext, grant: &Grant) -> Vec<ScopeRef> {
805 match Self::caller_of(Some(caller)) {
806 Some((p, layers)) => self.held_on_for(&p, &layers, grant),
807 None => Vec::new(),
808 }
809 }
810
811 pub fn check(&self, caller: Option<&AuthContext>, grant: &Grant, target: Option<&str>) -> Result<Reach, Refusal> {
820 let Some((principal, layers)) = Self::caller_of(caller) else {
821 return Err(Refusal::Unauthenticated);
822 };
823 if let Some(ctx) = caller {
824 self.alive(ctx).map_err(|reason| Refusal::Ended { reason })?;
825 }
826 let held_on = self.held_on_for(&principal, &layers, grant);
827 let (allowed, scope) = match target {
828 None => (!held_on.is_empty(), ScopeRef::Everywhere),
829 Some(t) => match self.inner.resolve.chain(t) {
830 None => (false, ScopeRef::named(t)),
831 Some(chain) => {
832 let in_chain = |s: &ScopeRef| s.is_everywhere() || chain.contains(s);
833 let by_membership = self
834 .inner
835 .memberships
836 .held(&principal)
837 .iter()
838 .any(|m| in_chain(&m.scope) && self.lists(&m.role, grant));
839 let by_ceiling = layers
840 .iter()
841 .all(|layer| layer.0.iter().any(|(rg, s)| in_chain(s) && self.entry_allows(rg, grant)));
842 let scope = chain.first().cloned().unwrap_or_else(|| ScopeRef::named(t));
843 (by_membership && by_ceiling, scope)
844 }
845 },
846 };
847 if allowed {
848 Ok(Reach {
849 held_on,
850 live: Some(Live { gate: self.clone(), caller: caller.cloned(), grant: grant.clone() }),
851 })
852 } else {
853 Err(Refusal::MissingGrant { grant: grant.clone(), scope, roles: self.roles_listing(grant), held_on })
854 }
855 }
856
857 pub fn reach_of_public(&self, caller: Option<&AuthContext>, grant: &Grant) -> Reach {
861 self.check(caller, grant, None).unwrap_or_else(|_| Reach {
862 held_on: Vec::new(),
863 live: Some(Live { gate: self.clone(), caller: caller.cloned(), grant: grant.clone() }),
864 })
865 }
866}
867
868#[cfg(test)]
873mod tests {
874 use super::*;
875 use std::sync::Mutex;
876
877 const ADA: &str = "key:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
878 const BOB: &str = "key:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
879
880 #[derive(Default)]
882 struct Members(Mutex<Vec<Membership>>);
883 impl Members {
884 fn grant(&self, who: &str, role: &str, scope: &str) {
885 self.0.lock().unwrap().push(Membership {
886 principal: who.parse().unwrap(),
887 role: RoleName::new(role),
888 scope: ScopeRef::parse(scope),
889 });
890 }
891 fn revoke_all(&self) {
892 self.0.lock().unwrap().clear();
893 }
894 }
895 impl Memberships for Members {
896 fn held(&self, who: &Principal) -> Vec<Membership> {
897 self.0.lock().unwrap().iter().filter(|m| &m.principal == who).cloned().collect()
898 }
899 }
900
901 struct Shortcodes;
904 impl Resolve for Shortcodes {
905 fn chain(&self, target: &str) -> Option<Vec<ScopeRef>> {
906 let code = target.split_once('-').map(|(c, _)| c).unwrap_or(target);
907 let mut chain = Vec::new();
908 if target.contains('-') {
909 chain.push(ScopeRef::named(target));
910 }
911 match code {
912 "MENGER" | "IDENTITY" => {
913 chain.push(ScopeRef::named(code));
914 chain.push(ScopeRef::named("PLEXUS"));
915 }
916 "PLEXUS" => chain.push(ScopeRef::named("PLEXUS")),
917 _ => return None,
918 }
919 chain.push(ScopeRef::Everywhere);
920 Some(chain)
921 }
922 }
923
924 fn roles() -> RoleTable {
925 RoleTable::new()
926 .define("viewer", ["tickets.get", "tickets.list"])
927 .unwrap()
928 .define("editor", ["viewer", "tickets.set_status"])
929 .unwrap()
930 }
931
932 fn gate(members: &Arc<Members>) -> Gate {
933 Gate::new(members.clone(), Arc::new(roles()), Arc::new(Shortcodes))
934 }
935
936 fn who(p: &str) -> AuthContext {
937 AuthContext::for_principal(&p.parse().unwrap(), "s1", vec![], serde_json::Value::Null)
938 }
939
940 fn with_ceiling(p: &str, ceiling: serde_json::Value) -> AuthContext {
941 AuthContext::for_principal(&p.parse().unwrap(), "s1", vec![], serde_json::json!({ CEILING_KEY: ceiling }))
942 }
943
944 fn g(s: &str) -> Grant {
945 Grant::new(s)
946 }
947
948 #[test]
949 fn a_grant_no_role_lists_is_refused_to_all_but_admin() {
950 let m = Arc::new(Members::default());
951 m.grant(ADA, "editor", "*");
952 m.grant(BOB, "admin", "MENGER");
953 let gate = gate(&m);
954 let err = gate.check(Some(&who(ADA)), &g("members.grant"), Some("MENGER-1")).unwrap_err();
955 assert_eq!(
956 err,
957 Refusal::MissingGrant {
958 grant: g("members.grant"),
959 scope: ScopeRef::named("MENGER-1"),
960 roles: vec![RoleName::new("admin")],
961 held_on: vec![],
962 }
963 );
964 assert!(gate.check(Some(&who(BOB)), &g("members.grant"), Some("MENGER-1")).is_ok());
965 assert!(gate.check(Some(&who(BOB)), &g("members.grant"), Some("IDENTITY-1")).is_err());
967 }
968
969 #[test]
970 fn held_on_a_scope_allows_targets_in_its_chain_only() {
971 let m = Arc::new(Members::default());
972 m.grant(ADA, "editor", "MENGER");
973 let gate = gate(&m);
974 let reach = gate.check(Some(&who(ADA)), &g("tickets.set_status"), Some("MENGER-12")).unwrap();
975 assert_eq!(reach.held_on(), &[ScopeRef::named("MENGER")]);
976 let err = gate.check(Some(&who(ADA)), &g("tickets.set_status"), Some("IDENTITY-1")).unwrap_err();
977 assert_eq!(
978 err,
979 Refusal::MissingGrant {
980 grant: g("tickets.set_status"),
981 scope: ScopeRef::named("IDENTITY-1"),
982 roles: vec![RoleName::new("editor"), RoleName::new("admin")],
983 held_on: vec![ScopeRef::named("MENGER")],
984 }
985 );
986 assert_eq!(err.to_string(), "needs tickets.set_status on IDENTITY-1");
987 assert!(gate.check(Some(&who(ADA)), &g("tickets.get"), Some("NOPE-1")).is_err());
989 }
990
991 #[test]
992 fn held_on_everywhere_allows_any_target_and_reach_is_everywhere() {
993 let m = Arc::new(Members::default());
994 m.grant(ADA, "viewer", "*");
995 m.grant(ADA, "viewer", "MENGER");
996 let gate = gate(&m);
997 let reach = gate.check(Some(&who(ADA)), &g("tickets.get"), Some("IDENTITY-3")).unwrap();
998 assert!(reach.is_everywhere());
999 assert_eq!(reach.held_on(), &[ScopeRef::Everywhere]);
1000 assert!(gate.check(Some(&who(ADA)), &g("tickets.list"), None).unwrap().is_everywhere());
1001 assert!(gate.check(Some(&who(ADA)), &g("tickets.set_status"), Some("IDENTITY-3")).is_err());
1003 }
1004
1005 #[test]
1006 fn without_a_target_held_anywhere_suffices_and_reach_says_where() {
1007 let m = Arc::new(Members::default());
1008 m.grant(ADA, "viewer", "MENGER");
1009 m.grant(ADA, "viewer", "IDENTITY");
1010 let gate = gate(&m);
1011 let reach = gate.check(Some(&who(ADA)), &g("tickets.list"), None).unwrap();
1012 assert_eq!(reach.held_on(), &[ScopeRef::named("IDENTITY"), ScopeRef::named("MENGER")]);
1013 assert!(reach.allows("MENGER-4"));
1014 assert!(!reach.allows("PLEXUS-1"));
1015 let err = gate.check(Some(&who(BOB)), &g("tickets.list"), None).unwrap_err();
1016 assert!(matches!(err, Refusal::MissingGrant { ref scope, .. } if scope.is_everywhere()));
1017 }
1018
1019 #[test]
1020 fn a_ceiling_narrows_the_membership() {
1021 let m = Arc::new(Members::default());
1022 m.grant(ADA, "editor", "MENGER");
1023 let gate = gate(&m);
1024 let narrowed = with_ceiling(ADA, serde_json::json!(["editor@MENGER-12"]));
1025 assert!(gate.check(Some(&narrowed), &g("tickets.set_status"), Some("MENGER-12")).is_ok());
1026 assert!(gate.check(Some(&narrowed), &g("tickets.set_status"), Some("MENGER-13")).is_err());
1027 let reach = gate.check(Some(&narrowed), &g("tickets.list"), None).unwrap();
1029 assert_eq!(reach.held_on(), &[ScopeRef::named("MENGER-12")]);
1030 let only_get = with_ceiling(ADA, serde_json::json!([["tickets.get@*"]]));
1032 assert!(gate.check(Some(&only_get), &g("tickets.get"), Some("MENGER-1")).is_ok());
1033 let err = gate.check(Some(&only_get), &g("tickets.set_status"), Some("MENGER-1")).unwrap_err();
1034 assert!(matches!(err, Refusal::MissingGrant { ref held_on, .. } if held_on.is_empty()));
1035 let layered = with_ceiling(ADA, serde_json::json!([["editor@*"], ["viewer@MENGER"]]));
1037 assert!(gate.check(Some(&layered), &g("tickets.get"), Some("MENGER-1")).is_ok());
1038 assert!(gate.check(Some(&layered), &g("tickets.set_status"), Some("MENGER-1")).is_err());
1039 let wider = with_ceiling(ADA, serde_json::json!(["editor@IDENTITY"]));
1041 assert!(gate.check(Some(&wider), &g("tickets.get"), Some("IDENTITY-1")).is_err());
1042 let bad = with_ceiling(ADA, serde_json::json!("editor@*"));
1044 assert!(gate.check(Some(&bad), &g("tickets.get"), Some("MENGER-1")).is_err());
1045 }
1046
1047 #[test]
1048 fn role_inclusion_flattens_and_must_name_an_earlier_role() {
1049 let r = roles();
1050 let editor = r.grants(&RoleName::new("editor")).unwrap();
1051 assert!(editor.contains(&g("tickets.get")) && editor.contains(&g("tickets.set_status")));
1052 let viewer = r.grants(&RoleName::new("viewer")).unwrap();
1053 assert!(!viewer.contains(&g("tickets.set_status")));
1054 assert_eq!(
1055 RoleTable::new().define("editor", ["viewer"]).unwrap_err(),
1056 RoleTableError::UnknownRole { role: "editor".into(), includes: "viewer".into() }
1057 );
1058 assert_eq!(r.grants(&RoleName::new("admin")), Some(GrantSet::All));
1060 let merged = RoleTable::from_lists([("editor", vec!["tickets.get"]), ("editor", vec!["comments.add"])]);
1062 let e = merged.grants(&RoleName::new("editor")).unwrap();
1063 assert!(e.contains(&g("tickets.get")) && e.contains(&g("comments.add")));
1064 }
1065
1066 #[test]
1067 fn anonymous_is_unauthenticated() {
1068 let m = Arc::new(Members::default());
1069 let gate = gate(&m);
1070 assert_eq!(gate.check(None, &g("tickets.get"), Some("MENGER-1")).unwrap_err(), Refusal::Unauthenticated);
1071 assert_eq!(
1072 gate.check(Some(&AuthContext::anonymous()), &g("tickets.list"), None).unwrap_err(),
1073 Refusal::Unauthenticated
1074 );
1075 assert!(gate.reach_of_public(None, &g("auth.login")).is_empty());
1077 }
1078
1079 #[test]
1080 fn a_live_reach_follows_grants_as_they_stand() {
1081 let m = Arc::new(Members::default());
1082 m.grant(ADA, "viewer", "MENGER");
1083 let gate = gate(&m);
1084 let reach = gate.check(Some(&who(ADA)), &g("tickets.list"), None).unwrap();
1085 assert!(reach.allows("MENGER-1"));
1086 assert!(reach.current().is_some());
1087 m.revoke_all();
1088 assert!(!reach.allows("MENGER-1"));
1089 assert!(reach.current().is_none());
1090 assert!(Reach::everywhere().allows("ANY-1") && Reach::everywhere().current().is_some());
1092 }
1093
1094 #[test]
1095 fn scope_refs_and_ceilings_round_trip() {
1096 assert_eq!(serde_json::to_string(&ScopeRef::Everywhere).unwrap(), "\"*\"");
1097 assert_eq!(serde_json::from_str::<ScopeRef>("\"MENGER\"").unwrap(), ScopeRef::named("MENGER"));
1098 let c = Ceiling::parse(["editor@MENGER-12", "tickets.get@*"]).unwrap();
1099 assert_eq!(c.0[0], (RoleOrGrant::Role(RoleName::new("editor")), ScopeRef::named("MENGER-12")));
1100 assert_eq!(c.0[1], (RoleOrGrant::Grant(g("tickets.get")), ScopeRef::Everywhere));
1101 assert_eq!(c.text(), vec!["editor@MENGER-12", "tickets.get@*"]);
1102 assert!(Ceiling::parse(["editor"]).is_err());
1103 }
1104
1105 #[derive(Default)]
1107 struct Switch(std::sync::atomic::AtomicBool);
1108 impl Liveness for Switch {
1109 fn alive(&self, _: &AuthContext) -> Result<(), String> {
1110 if self.0.load(std::sync::atomic::Ordering::SeqCst) {
1111 Err("you have signed out: sign in again".into())
1112 } else {
1113 Ok(())
1114 }
1115 }
1116 }
1117
1118 #[test]
1121 fn a_session_that_ended_holds_nothing() {
1122 let m = Arc::new(Members::default());
1123 m.grant(ADA, "admin", "*");
1124 let out = Arc::new(Switch::default());
1125 let gate = gate(&m).with_liveness(out.clone());
1126 let reach = gate.check(Some(&who(ADA)), &g("auth.grant"), None).expect("admin before sign-out");
1127 assert!(reach.allows("MENGER-1"));
1128 out.0.store(true, std::sync::atomic::Ordering::SeqCst);
1129 let ended = Refusal::Ended { reason: "you have signed out: sign in again".into() };
1130 assert_eq!(gate.check(Some(&who(ADA)), &g("auth.grant"), None).unwrap_err(), ended);
1131 assert_eq!(gate.check(Some(&who(ADA)), &g("tickets.get"), Some("MENGER-1")).unwrap_err(), ended);
1132 assert!(!reach.allows("MENGER-1"), "a stream's next event sees it");
1133 assert!(reach.current().is_none());
1134 assert!(gate.reach_of_public(Some(&who(ADA)), &g("auth.grant")).is_empty());
1135 assert_eq!(gate.check(None, &g("auth.grant"), None).unwrap_err(), Refusal::Unauthenticated);
1137 }
1138
1139 #[test]
1142 fn an_expired_sign_in_holds_nothing() {
1143 let m = Arc::new(Members::default());
1144 m.grant(ADA, "admin", "*");
1145 let gate = gate(&m);
1146 let past = AuthContext::for_principal(&ADA.parse().unwrap(), "s1", vec![], serde_json::json!({ "expires_at": 1 }));
1147 assert!(matches!(gate.check(Some(&past), &g("auth.grant"), None), Err(Refusal::Ended { .. })));
1148 let future = AuthContext::for_principal(&ADA.parse().unwrap(), "s1", vec![], serde_json::json!({ "expires_at": i64::MAX }));
1149 assert!(gate.check(Some(&future), &g("auth.grant"), None).is_ok());
1150 }
1151}