qualia_cooperative_core/authoring/
policy.rs1use super::*;
2use crate::projects::ProjectRole;
3
4#[derive(Debug)]
8pub struct AuthoringPermit<'a> {
9 pub(super) view: &'a HostAuthorityView<'a>,
10 pub(super) principal: &'a AuthenticatedPrincipal<'a>,
11 pub(super) membership: &'a AdmittedMembership<'a>,
12 pub(super) identifier: &'a QualifiedIdentifier<'a>,
13 pub(super) review_grant: Option<&'a ReviewGrant<'a>>,
14 pub(super) action: AuthoringAction,
15}
16
17pub(super) fn text(value: &str, limits: AuthoringLimits) -> Result<(), AuthoringError> {
18 if value.is_empty() || value.len() > limits.max_text_bytes {
19 return Err(AuthoringError::InvalidBinding);
20 }
21 Ok(())
22}
23
24pub(super) fn valid_window(now: u64, start: u64, end: u64) -> bool {
25 start < end && start <= now && now < end
26}
27
28pub(super) fn valid_document(
29 document: &DocumentRevision,
30 limits: AuthoringLimits,
31) -> Result<(), AuthoringError> {
32 text(&document.project_id, limits)?;
33 text(&document.document_id, limits)?;
34 text(&document.source_id, limits)?;
35 if let Some(author) = &document.author_subject {
36 text(author, limits)?;
37 }
38 if document.source_digest == [0; 32] {
39 return Err(AuthoringError::InvalidBinding);
40 }
41 Ok(())
42}
43
44pub fn authorize<'a>(
48 view: &'a HostAuthorityView<'a>,
49 request: &AuthoringRequest<'_>,
50) -> Result<AuthoringPermit<'a>, AuthoringError> {
51 let principal = view.principal.ok_or(AuthoringError::Unauthenticated)?;
52 let limits = view.limits;
53 if principal.identifiers.len() > limits.max_identifiers
54 || view.memberships.len() > limits.max_memberships
55 || view.review_grants.len() > limits.max_review_grants
56 {
57 return Err(AuthoringError::BudgetExceeded);
58 }
59 text(principal.subject, limits)?;
60 text(principal.authentication_ref, limits)?;
61 if view.now_unix >= principal.authenticated_until_unix {
62 return Err(AuthoringError::Unauthenticated);
63 }
64 if view.generation == 0 || view.generation != request.expected_authority_generation {
65 return Err(AuthoringError::StaleAuthority);
66 }
67 valid_document(view.current_document, limits)?;
68 valid_document(request.target, limits)?;
69 text(&view.project.id, limits)?;
70 if view.current_document.project_id != view.project.id {
71 return Err(AuthoringError::InvalidBinding);
72 }
73 if request.target != view.current_document {
74 return Err(AuthoringError::StaleDocument);
75 }
76 for identifier in principal.identifiers {
79 for value in [
80 identifier.value,
81 identifier.scheme,
82 identifier.issuer,
83 identifier.project_id,
84 identifier.evidence_ref,
85 ] {
86 text(value, limits)?;
87 }
88 }
89 let mut admitted = None;
90 let mut matched_identifier = None;
91 for member in view.memberships {
92 let membership = member.membership;
93 for value in [
94 &membership.id,
95 &membership.project_id,
96 &membership.member_did,
97 ] {
98 text(value, limits)?;
99 }
100 text(member.member_subject, limits)?;
101 text(member.admission_ref, limits)?;
102 if member.member_subject != principal.subject || membership.project_id != view.project.id {
103 continue;
104 }
105 if member.revoked
106 || !valid_window(
107 view.now_unix,
108 member.valid_from_unix,
109 member.valid_until_unix,
110 )
111 || u64::try_from(membership.agreed_at().to_unix_secs())
112 .map_or(true, |agreed_at| agreed_at > view.now_unix)
113 {
114 return Err(AuthoringError::NotMember);
115 }
116 for identifier in principal.identifiers {
117 if identifier.value != membership.member_did || identifier.project_id != view.project.id
118 {
119 continue;
120 }
121 if identifier.revoked
122 || !valid_window(
123 view.now_unix,
124 identifier.valid_from_unix,
125 identifier.valid_until_unix,
126 )
127 || matched_identifier.is_some()
128 {
129 return Err(AuthoringError::NotMember);
130 }
131 matched_identifier = Some(identifier);
132 }
133 if matched_identifier.is_none() || admitted.is_some() {
134 return Err(AuthoringError::NotMember);
135 }
136 admitted = Some(member);
137 }
138 let membership = admitted.ok_or(AuthoringError::NotMember)?;
139 let mut review_grant = None;
140 if request.action == AuthoringAction::ReviewDecision {
141 if view.current_document.author_subject.as_deref() == Some(principal.subject) {
142 return Err(AuthoringError::SelfReview);
143 }
144 if view.current_document.author_subject.is_none() {
145 return Err(AuthoringError::ReviewDenied);
146 }
147 for grant in view.review_grants {
148 for value in [
149 grant.id,
150 grant.project_id,
151 grant.document_id,
152 grant.reviewer_subject,
153 grant.admission_ref,
154 ] {
155 text(value, limits)?;
156 }
157 if grant.project_id != view.project.id
158 || grant.document_id != view.current_document.document_id
159 || grant.reviewer_subject != principal.subject
160 {
161 continue;
162 }
163 if grant.revoked
164 || !valid_window(view.now_unix, grant.valid_from_unix, grant.valid_until_unix)
165 || review_grant.is_some()
166 {
167 return Err(AuthoringError::ReviewDenied);
168 }
169 review_grant = Some(grant);
170 }
171 if review_grant.is_none() {
172 return Err(AuthoringError::ReviewDenied);
173 }
174 } else if request.action != AuthoringAction::ReadSource
175 && membership.membership.role == ProjectRole::Observer
176 {
177 return Err(AuthoringError::RoleDenied);
178 }
179 Ok(AuthoringPermit {
180 view,
181 principal,
182 membership,
183 identifier: matched_identifier.ok_or(AuthoringError::NotMember)?,
184 review_grant,
185 action: request.action,
186 })
187}
188
189impl AuthoringPermit<'_> {
190 pub fn action(&self) -> AuthoringAction {
191 self.action
192 }
193 pub fn principal_subject(&self) -> &str {
194 self.principal.subject
195 }
196 pub fn target(&self) -> &DocumentRevision {
197 self.view.current_document
198 }
199 pub fn authority_generation(&self) -> u64 {
200 self.view.generation
201 }
202}