Skip to main content

qualia_cooperative_core/authoring/
policy.rs

1use super::*;
2use crate::projects::ProjectRole;
3
4/// A borrowed decision, deliberately neither Clone nor Serialize. It is usable
5/// only while the host holds current state. Reauthorize every action; do not
6/// cache permits or release the owner lock before the operation commits.
7#[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
44/// Fail closed against the current cooperative owner. No heap allocation.
45/// Authentication and admission evidence are verified by the native host before
46/// constructing the view, not by this pure policy or by source-supplied strings.
47pub 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    // Check all bounded host records rather than allowing an invalid identifier
77    // association or revoked membership to be hidden by ordering duplicates.
78    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}